{"id":"95c2ff74-48c8-4546-bcc6-ff571b0521ba","arxiv_id":"2502.00508","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":4.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"PyMOLfold is an open-source PyMOL plugin that runs ESM3, Boltz-1, Chai-1, and Protenix locally or via API, and loads predicted structures directly into the viewer.","lead":"PyMOLfold is a free, open-source plugin that brings AI protein structure prediction models such as ESM3, Boltz-1, and Chai-1 directly into the PyMOL molecular viewer. It lets researchers paste an amino acid sequence, optionally add a ligand, and see the predicted 3D structure without leaving the program.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The paper's own Installation section concedes that conflicting dependencies can prevent installing multiple folding libraries in one Conda environment; this directly undercuts the advertised single-interface multi-model workflow unless the plugin supports isolated per-model environments.","rationale":"I read the paper as a software description whose central claim is that a user can complete folding and visualization in one PyMOL interface, with several models and optional ligand support. For that claim to hold, the supported backends must be usable from the same PyMOL session. The strongest concrete obstacle is the paper's own admission that multiple folding libraries may not be installable in the same Conda environment. This is not a disagreement with the scientific consensus about model accuracy; it is an internal limitation that bears directly on whether the advertised workflow is achievable as described. The reader's weakest assumption identified this same issue, and I agree. I do not think this requires changing the CONDITIONAL verdict: the paper is clearly written, the code is public and open source, and the plugin may well work for one model at a time or in separate environments. But before the broader claim can be accepted, the authors should either demonstrate co-installation of all four backends or document a supported way to run backends from isolated environments while keeping the PyMOL UI as the single entry point. The proposed concrete test would settle which of those situations holds.","tokens_in":5023,"tokens_out":6480,"duration_ms":68622,"concrete_test":"In a fresh conda environment matching the PyMOL version recommended in the repository, follow the Installation section's commands: activate the PyMOL env, then attempt to install all four supported model packages (esm, boltz, chai, protenix) into that one environment. If the dependency resolver produces conflicts that prevent at least one of the four packages from being installed, the multi-model selector cannot work in a single PyMOL instance; if all four install successfully, install the plugin and run one short sequence through each backend to confirm the UI can call all of them. Additionally, test whether PyMOLfold can invoke a model installed in a separate conda environment from the PyMOL UI; absent such a mechanism, the single-interface claim fails for co-installation conflicts.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim is that PyMOLfold lets a user, from one PyMOL UI, select among ESM3, Boltz-1, Chai-1, and Protenix and fold a sequence (with optional SMILES) in the active session. That claim presupposes that all supported model libraries can coexist in the same PyMOL Conda environment. The paper itself states: 'Note that it may be impossible to install multiple folding libraries in the same Conda environment due to their conflicting dependencies' (Installation section). Because PyMOL loads plugins from a single Python environment, the model selector cannot present all four backends in one installation if this conflict materializes. The text offers no fallback mechanism, such as subprocess calls into separate conda environments, containerization, or documented per-model PyMOL installs, so the 'one interface' benefit is not guaranteed and may reduce to one backend per environment. This is an internal limitation, not an external consensus disagreement, and it directly affects the scope of the strongest claim.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The manuscript describes PyMOLfold, an open-source PyMOL plugin that aims to let users run protein structure prediction with one of several AI models (ESM3, Boltz-1, Chai-1, Protenix) directly from the PyMOL interface, optionally providing a ligand SMILES string, and then visualize the predicted structure in the same session. The paper covers the user interface, backend logic, supported models, database retrieval from AlphaFoldDB and ModelArchive, installation instructions, and usage. No benchmark, test case, or end-to-end validation is provided; the central assertion is that the plugin provides a seamless one-interface folding-and-visualization workflow.","tokens_in":5154,"tokens_out":2038,"duration_ms":21711,"significance":"If the plugin works as described, it addresses a real usability gap in structural bioinformatics: users currently fold sequences in one environment and then import the resulting PDB file into PyMOL for visualization. The authors have made the source code publicly available under GPL-3.0, which is a concrete contribution that allows independent verification and community extension. However, the paper's central claim is a functionality claim about a piece of software, and the manuscript currently provides no evidence that the advertised multi-model, one-interface workflow actually operates end-to-end on supported platforms. The claim is plausible and the code is public, but the absence of validation and the installation-dependency caveat mean the contribution is not yet established to the standard expected for a software paper.","major_comments":[{"comment":"The Installation section states that 'it may be impossible to install multiple folding libraries in the same Conda environment due to their conflicting dependencies.' This is load-bearing for the central claim that PyMOLfold lets a user select among ESM3, Boltz-1, Chai-1, and Protenix from one interface: PyMOL loads plugins from a single Python environment, so if the dependencies conflict, the model selector cannot present all four backends in a single installation. The paper describes no fallback mechanism such as subprocess calls into separate Conda environments, containerization, or per-model PyMOL installs. The authors should either demonstrate that the supported model libraries can coexist in one environment for the documented versions, or implement and document isolated per-model execution so that the advertised one-interface workflow actually holds.","section":"Installation"},{"comment":"No validation protocol, test case, or benchmark is provided. The paper claims that 'in a few seconds, the sequence(s) will be folded and the structure will be loaded into PyMOL' and that PyMOLfold works for several models, but it does not show a single end-to-end example with a documented input sequence, a named model version, and the resulting structure (e.g., a PDB ID or a comparison of the output against a known structure). For a software-focused manuscript, at least one reproducible test case per supported model should be included, and ideally an automated test suite in the repository. Without this, the central claim that the plugin 'seamlessly integrates' all listed backends is unverified.","section":"Methods / Usage"},{"comment":"The paper describes ESM3 access through the EvolutionaryScale Forge API as one of the supported backends, but the Abstract claims that the plugin allows prediction 'without requiring external tools or complex workflows.' An API-key-dependent remote service is a different deployment model from the local libraries (Boltz-1, Chai-1, Protenix), and it has different failure modes (network, API versioning, key management). The authors should clarify in the abstract or introduction whether the plug-in's one-interface claim includes this remote path and what happens to the workflow when the API is unavailable or changes.","section":"Discussion / Supported Models"}],"minor_comments":[{"comment":"The phrase 'click the Fold button' appears as 'click the F oldbutton' due to a typesetting artifact; this should be corrected.","section":"Usage"},{"comment":"The text reads 'create temporary a FASTA file'; this should be 'create a temporary FASTA file'.","section":"Methods"},{"comment":"Author affiliation 4 appears as 'T uple LLC' and affiliation 7 has irregular spacing; these should be cleaned up.","section":"Authors / Affiliations"},{"comment":"The example command line '/home/<username>/biotools /pymol/bin/python -m pip install esm' contains a space before the path separator, which would be a typo for a real command; it should be written as '/home/<username>/biotools/pymol/bin/python -m pip install esm'.","section":"Installation"},{"comment":"The sentence 'the plugin’s open-source nature encourages community-driven development and collaboration' is broad; naming the repository and license earlier in the text would make the claim more concrete.","section":"Introduction"}],"recommendation":"major_revision","confidential_remarks":"This is a short software note with no quantitative claims, so the main risk is not circularity but unverified functionality. The installation-conflict caveat in the manuscript directly undercuts the advertised multi-model single-interface feature unless the authors demonstrate coexistence or add an isolation mechanism. Given that the code is public and the fix is likely achievable, major revision rather than rejection seems appropriate. I would also flag that the ESM3 API path and the local-model paths are operationally different, and the paper should be honest about that in the abstract."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"PyMOLfold is a real, open-source PyMOL plugin that wraps ESM3, Boltz-1, Chai-1, and Protenix, lets users paste a sequence and optional ligand SMILES, runs folding from the PyMOL UI, and loads the result into the session. It also fetches predicted structures from AlphaFoldDB and ModelArchive, and does UniProt lookups. That is genuinely useful for people who live in PyMOL and would rather not leave it to fold.\n\nWhat is new here is the integration, not the underlying algorithms. That is fine; many good tools are glue. The code is public and the installation and usage sections are clear enough that a motivated user can try it. I give credit for that.\n\nThe soft spots are real, but they are soft rather than fatal. First, there is no validation: no benchmark, no test case, no worked example of a successful fold per backend. The screenshots show the UI, not evidence that each model actually runs and loads. For a software paper, one short example per backend with runtime and hardware notes would have fixed this.\n\nSecond, the dependency warning in the Installation section is not a nitpick. The paper says: \"Note that it may be impossible to install multiple folding libraries in the same Conda environment due to their conflicting dependencies.\" PyMOL plugins run inside PyMOL's Python environment, so the promise of having ESM3, Boltz-1, Chai-1, and Protenix all selectable in one interface depends on these libraries coexisting. The per-model conda environment files help installation, but they do not solve the coexistence problem unless the user manually manages environments; the paper does not describe isolated subprocess or container calls. So in practice, users may get one backend per PyMOL install. That softens the strongest claim, but it does not kill the paper.\n\nThird, there is no comparison with prior PyMOL plugins for folding or structure retrieval, so \"unique capability\" is asserted rather than shown. Minor in a short software note, but a quick survey would have helped.\n\nThe citation pattern looks fine; no self-citation issues. The authors are honest about future work.\n\nWho is this for? Structural biologists and bioinformaticians who use PyMOL and want to fold without leaving it. It deserves a serious referee. A referee should ask for one validation example per backend and for a concrete answer to the dependency-coexistence problem before acceptance.","headline":"A useful, honest PyMOL plugin paper that wraps four folding backends into one UI, but the one-interface promise is undercut by its own dependency-conflict warning and a total lack of validation.","tokens_in":5735,"tokens_out":2402,"would_cite":true,"duration_ms":24400,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"PyMOLfold is an open-source PyMOL plugin that lets users run AI protein structure prediction—including ESM3, Boltz-1, Chai-1, and Protenix—and load the resulting structures directly into the active PyMOL session, with optional ligand…","keywords":["PyMOL plugin","protein structure prediction","ESM3","Boltz-1","Chai-1","Protenix","ligand SMILES","AlphaFoldDB"],"falsifier":"Install PyMOLfold into a fresh PyMOL Conda environment, then attempt to install Boltz-1, Chai-1, and Protenix side by side and fold the same test sequence with each model by clicking Fold; if any model fails to install or its output fails to appear in the session, the claimed all-in-one workflow is not delivered in that configuration.","tokens_in":4804,"feed_emoji":"🧬","tokens_out":6214,"duration_ms":52617,"temperature":0.7,"pith_summary":"PyMOLfold is an open-source plugin that brings AI-based protein structure prediction into the PyMOL molecular graphics program. The paper's central claim is that a researcher can paste an amino acid sequence (and, with some models, a ligand SMILES string), run a supported folding model such as ESM3, Boltz-1, Chai-1, or Protenix, and immediately get the predicted three-dimensional structure loaded into the active PyMOL session. This matters because it collapses the usual two-step workflow of predicting in one program and visualizing in another into a single interface. The authors also integrate retrieval of predicted structures from AlphaFoldDB and ModelArchive, so experimentally determined and predicted structures can be examined side by side.","feed_headline":"PyMOL plugin folds proteins and places ligands in one window","feed_subtitle":"Paste a sequence, add an optional SMILES string, and explore the predicted 3D structure right in the viewer.","key_machinery":"The central object is the PyMOLfold plugin itself: a PyQt5 user interface paired with a Python 3 backend that dispatches folding jobs to whichever model the user selects. The load-bearing mechanism is the conversion layer between the user's sequence (and optional ligand SMILES) and the input format each model expects—temporary FASTA files for some models, JSON files for others, and direct function calls for the rest. A second mechanism is the database-retrieval layer, which fetches predicted structures from AlphaFoldDB and ModelArchive by accession ID and sequence information from UniProt, all inside the PyMOL window.","core_discovery":"The discovery is an application-level integration: a PyQt5-based graphical user interface that calls the Python libraries of Boltz-1, Chai-1, and Protenix for local folding, and the ESM3 Forge API for remote folding, then loads the returned coordinate files as ordinary PyMOL objects. For file-based models the plugin prepares temporary FASTA or JSON inputs with chain and sequence metadata; for library-based models it passes the sequence directly to the folding function. With Boltz-1 and Chai-1 a SMILES string can be included so the small molecule is placed in the predicted complex. Once loaded, the structure is interactive and customizable like any PDB-derived structure, and can be colored by AlphaFold-style confidence.","pith_inferences":["Going beyond the paper, the same plugin pattern could be extended to nucleic-acid-containing complexes, since Chai-1 already handles DNA and RNA, though the current interface exposes only protein sequence plus optional small-molecule SMILES.","Going beyond the paper, the dependency-conflict caveat suggests that a container-based or fully remote execution layer would be the natural next step to make the 'one interface for every model' promise hold in practice.","Going beyond the paper, because predicted structures load as ordinary PyMOL objects, downstream tasks such as mutagenesis, surface analysis, and figure generation become immediately available on freshly predicted models, not only on experimentally determined ones.","Going beyond the paper, the absence of benchmark data means the plugin's utility stands or falls on workflow integration rather than prediction accuracy; a head-to-head timing comparison with a manual predict-then-load pipeline would quantify the claimed streamlining."],"forward_implications":["A user can go from a primary amino acid sequence to an interactive, saved three-dimensional structure prediction without leaving PyMOL or manually moving .PDB files between programs.","For supported models, providing a ligand SMILES string produces a predicted protein–ligand complex in which the small molecule is already placed, making the same interface usable for early-stage binding hypotheses.","Researchers can pull predicted models from AlphaFoldDB or ModelArchive alongside experimental PDB entries, enabling direct visual comparison in one session.","Because the plugin is open-source and the model libraries are pluggable, adding a newly released folding model requires only a new backend adapter to the existing UI.","The single-environment installation path is the practical condition: users must install the chosen model library into PyMOL's Python environment, with per-model Conda environment files provided as fallback."],"supporting_citations":[{"why":"Supplies the Boltz-1 model that PyMOLfold calls for local biomolecular interaction modeling.","marker":"[3]"},{"why":"Supplies the Chai-1 foundation model that PyMOLfold uses for proteins and small molecules.","marker":"[4]"},{"why":"Supplies the Protenix AlphaFold3 reproduction that PyMOLfold supports as a local model.","marker":"[5]"},{"why":"Supplies the ESM3 language-model API that PyMOLfold uses for remote folding.","marker":"[6]"},{"why":"Provides the Protein Data Bank retrieval that the plugin builds on for experimental structures.","marker":"[7]"},{"why":"Defines the AlphaFoldDB repository from which PyMOLfold retrieves predicted structures by accession ID.","marker":"[8]"},{"why":"Defines the ModelArchive repository from which PyMOLfold retrieves computational model structures.","marker":"[9]"},{"why":"Provides the UniProt sequence search that PyMOLfold uses to load and edit a protein sequence before folding.","marker":"[10]"},{"why":"Establishes the accessibility precedent (ColabFold) that PyMOLfold extends by folding and visualizing in one interface.","marker":"[13]"}],"fun_headline_variants":["PyMOL plugin folds proteins, places ligands in one view","AI protein folding with ligand placement inside PyMOL","Fold sequences into 3D structures with ligands in PyMOL","PyMOL plugin: predict protein and ligand structures interactively"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The plugin only works if the third-party model programs (Boltz-1, Chai-1, Protenix) and the ESM3 online service can be installed and run inside the Python environment that comes with PyMOL, and the authors acknowledge that conflicting dependencies can make it impossible to install several of them side by side.","fun_headline_variants_meta":{"raw":{"variants":["PyMOL plugin folds proteins, places ligands in one view","AI protein folding with ligand placement inside PyMOL","Fold sequences into 3D structures with ligands in PyMOL","PyMOL plugin: predict protein and ligand structures interactively"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000192,"raw_usage":{"total_tokens":1285,"prompt_tokens":820,"completion_tokens":465,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":436,"completion_tokens_details":{"reasoning_tokens":395}},"tokens_in":436,"tokens_out":465,"duration_ms":4616,"temperature":1.0,"reasoning_tokens":395,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-09T18:41:34.406957+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Install PyMOLfold into a fresh PyMOL Conda environment, then attempt to install Boltz-1, Chai-1, and Protenix side by side and fold the same test sequence with each model by clicking Fold; if any model fails to install or its output fails to appear in the session, the claimed all-in-one workflow is not delivered in that configuration.","supporting_citations":[{"cited_title":"Protenix: Advancing structure prediction through a comprehensive alphafold3 reproduction","cited_arxiv_id":null,"evidence_quote":"Supplies the Protenix AlphaFold3 reproduction that PyMOLfold supports as a local model."},{"cited_title":"Berman, David Jones, Steven E","cited_arxiv_id":null,"evidence_quote":"Defines the ModelArchive repository from which PyMOLfold retrieves computational model structures."}],"review_version":1}