When bringing large language models into frontier science, many expect them to directly propose revolutionary hypotheses or discover miracle drugs in the lab. In reality, a far more dependable path is much more grounded: start by helping scientists overhaul the computational software they run every day—tools that are notoriously slow and resource-heavy. A technical report and open-source codebase released by Anthropic on September 17 document exactly such an effort.
The division of labor in this work is intriguing. Two technical contributors with backgrounds in biomolecular modeling—but lacking experience in inference acceleration or low-level kernel development—guided Claude to refactor 36 software packages covering more than 30 open-source biomolecular models in under four weeks. All modifications run directly on top of existing model weights; the team trained no new models. The difference between 36 packages and over 30 models stems mainly from multiple independent implementations and parameter variants for certain models. The text of the technical report and the data analysis were likewise drafted by Claude under human supervision.
When deploying general-purpose frontier models on the scientific front lines, there is no need to rush to make core scientific judgments for scientists. Instead, roll up your sleeves and give the computational software researchers rely on daily a solid technical renovation. Judged by practical results, this pragmatic engineering route sidesteps the direct risk of scientific hallucinations while making existing scientific computing tools genuinely faster and more resource-efficient.
In computational biology’s everyday R&D pipelines, researchers’ compute budgets are consumed primarily by two foundational tasks. One is protein structure prediction, where a program takes an amino acid or nucleotide sequence, computes atomic coordinates in 3D space, and evaluates local confidence. The other is protein design, where algorithms start from the surface of a disease target and generate entirely new sequences capable of binding tightly—often in the form of small protein binders of 50 to 120 residues—followed by refolding prediction to verify binding conformations. Both tasks are not only time-consuming, but also routinely blow past the VRAM limits of high-end accelerator cards.
Why do mainstream models run so slowly? We can think of a protein molecule as a string of beads folded in 3D space. To figure out what shape this string of beads will ultimately fold into, mainstream architectures exemplified by AlphaFold3, OpenFold3, and Boltz-2 must repeatedly calculate the relative spatial positions between every pair of beads. Purely for illustration, assume a chain has 1,000 beads. Excluding directionality and self-pairing, pairwise combinations alone yield roughly 500,000 pairs. The model writes down a relationship card for each pair of beads, recording the distance and orientation between them.
The trouble lies in the validation process for these relationship cards. To check whether the card between bead 1 and bead 2 is correct, the algorithm cannot simply inspect those two beads in isolation; it must also pull in bead 3, bead 4, and every subsequent bead along the molecular chain, checking whether the geometric triangle formed by any three beads satisfies the laws of physics and geometry. Updating the relationship card for every pair requires a round of checks against every other bead in the entire system. With each additional bead on the chain, an entire new batch of pairwise relationship cards is created, and each card must be cross-checked against one additional bead.
This exponentially entangled verification of geometric triangles is known in the computational biology literature as triangular attention and triangular multiplicative updates. The computational cost of these pairwise operations scales cubically with the size of the molecular system. Doubling the residue count within a system causes the required compute time and VRAM footprint to soar by approximately 8x; tripling the system size causes resource demands to explode by roughly 27x. The vast majority of runtime and memory overhead in modern structure prediction models is spent precisely on the cross-deduction of these relationship cards.
Historically, resolving engineering bottlenecks of this kind often required experienced low-level systems engineers to spend weeks hand-tuning a single model, and the resulting low-level code was difficult to port directly to others. Although chip vendors have introduced specialized operator libraries like cuEquivariance and the BioNeMo inference runtime, the academic world is scattered across dozens of independently evolving open-source model repositories. Expert hand-crafting can hardly cover the entire tool ecosystem, leaving many excellent scientific software packages lingering in unoptimized native states for long periods.
Facing over thirty model codebases with diverse architectures, the refactoring strategy was split into two levels: low-level hardware operators and upper-level model engineering. Low-level GPU kernels are essentially low-level programs that fuse many granular operations into a few high-throughput bulk operations. Conventional code typically split complex triangular geometric calculations into dozens of piecemeal mathematical instructions, causing intermediate data to be shuttled back and forth between VRAM and compute cores, wasting substantial bandwidth. The team had Claude write a custom GPU kernel named FlashPairformer, fusing these fragmented steps into a saturated, continuous streaming operation that curbed memory read-write latency. In isolated tests, triangular attention achieved a geometric mean speedup of 2.7 to 2.9x relative to cuEquivariance. While such microbenchmarks do not equate to end-to-end model speedups, they cleared low-level roadblocks for higher-level optimizations.
The heavier engineering burden lay in refactoring the code across the 36 software packages. Crucially, what changed were execution paths and memory scheduling, not the mathematical formulations tools use to derive scientific conclusions. What Claude did was systematically eliminate mechanical friction during execution. Two actions were most representative: first, caching intermediate results that were previously recomputed redundantly, sparing the program wasted effort; second, using CUDA Graph technology to record repetitive GPU operations and replay them in batches, eliminating Python interpreter dispatch overhead on every small step. The code also folded constant dead branches, pinned high-frequency tensors in VRAM to reduce host-to-device data copies, and introduced asynchronous pipelines for data loading. For massive complexes, the program chunks enormous intermediate tensors or, in single-node multi-GPU setups, shards pairwise representations across GPUs by row for collaborative computation.
In traditional performance optimization, low-level engineers often sacrifice a bit of precision on the user’s behalf in exchange for speed. This work returns the authority over precision and resources to researchers by designing four operating modes. Users can switch modes according to their task scenario: off mode disables optimizations entirely, preserving the stock state; exact mode guarantees bitwise-identical output values to the original model; fast mode allows outputs to fall within the original model’s own stochastic variation range in exchange for more substantial inference speed; and big mode specifically enables memory chunking and multi-GPU sharding to prevent out-of-memory errors when processing large macromolecules.
This engineering framework also introduced an explicit rejection contract. If the execution environment, hardware configuration, or model architecture cannot satisfy the requirements of a given mode, the program prints a NOT ACTIVE notice and exits with status code 3, rather than silently falling back to unaccelerated slow code. All refactored code has been organized in an open-source repository, with original upstream code kept in the stock directory, optimized packages placed in the opt directory, and a shared underlying opt_core runtime. The entire project is published as a static reference implementation: Anthropic’s own code is licensed under Apache-2.0, upstream stock code retains its respective licenses, and the team explicitly stated that they will not accept community contributions or provide ongoing maintenance going forward.
To objectively evaluate the speedups achieved by this code refactoring, one must first clarify the baseline of comparison. Speed and memory benchmarks were uniformly conducted on NVIDIA H100 80GB GPUs. The default baseline selected by the evaluation team was not an out-of-the-box default, but the fastest correct configuration tuned by knowledgeable users on the same GPU, with optional fused operators enabled in advance and batch throughput saturated. Speedup factors were compared directly against this high-efficiency baseline tuned by proficient engineers, eliminating inflated numbers stemming from unoptimized out-of-the-box setups.
Against this rigorous baseline, the three optimization modes across the structure prediction subset demonstrated a clear performance ladder—all figures below are geometric means. The exact mode, which preserves bitwise-identical output, achieved an average speedup of 1.6x; the fast mode, which trades minor numerical discrepancies for speed, averaged a 4.1x speedup, with acceleration across individual models ranging between 2.3x and 6.4x, and these small numerical drifts remained within the original models’ own stochastic variation; the memory-saving big mode, even while shouldering the overhead of data chunking, still attained an average speedup of 3.4x. The “nearly 2x” bitwise-identical speedup mentioned in the official announcement reflects the global average across all thirty-plus models; on the compute-heavy structure prediction subset, the strictly bitwise-identical speedup was in fact 1.6x.
Pursuing maximum speed comes at a memory cost. To maximize peak computational throughput, VRAM consumption in exact and fast modes can surge to more than 3x the original baseline. If available GPU memory is tight, users need to switch to the memory-conservative big mode, relying on chunked computation to circumvent out-of-memory risks.
With computation running faster, did output quality suffer? Researchers examined the accuracy of predicted conformations using threshold-based metrics. In protein structure prediction, researchers commonly use the DockQ score to measure how closely predicted models match experimentally determined structures, treating 0.23 as the threshold for an acceptable prediction. Benchmark data show that when compared against experimentally resolved structures, the acceptable proportion remained steady at the 54% to 55% level both before and after optimization. The confidence intervals for the various optimization modes relative to the baseline all encompass zero, indicating that overall accuracy across the board remained stable without systematic degradation.
Naturally, the report’s appendix includes per-model evaluation details, showing minor localized accuracy fluctuations for a handful of models under specific modes. Additionally, the report did not compare against the community acceleration kernels newly added to ColabFold during the same period.
Every software engineering optimization has its limits. This technical report maintains admirable academic discipline, using two sets of controlled experiments to draw a clear line between the reach of computational engineering and the validity of scientific prediction.
The first boundary emerged in structure prediction for ultra-large molecular complexes. Biophysical computing uses biological tokens to quantify the scale of physical entities: one per amino acid residue, one per nucleotide, and each non-hydrogen atom counted individually for small-molecule ligands and ions. This unit reflects the actual geometric entities of the molecular system and bears no mathematical relationship to the tokens used by large language models to tokenize text. On a single 8-GPU server, big mode successfully predicted massive complexes containing over 10,000 biological tokens—with the largest test sample reaching 10,761 tokens—achieving structural similarity TM-scores between 0.92 and 0.997. By comparison, the ribosome case presented when the AlphaFold3 paper was published was 7,663 tokens in size, while the upper sampling limit during the model’s training phase was just 768 tokens.
Yet having sufficient compute to finish a run does not mean the scientific inference holds true. When faced with intact viral capsids and enormous protein compartments containing roughly 31,000 to 70,320 residues, all 7 extreme inference runs on a single server completed smoothly, but the output 3D structures all collapsed into dense globules with diameters only about a quarter of their true conformations, and TM-scores for the three scored systems plummeted to between 0.08 and 0.14.
Readers will inevitably wonder: did this collapse stem from the acceleration optimizations, or perhaps from numerical errors introduced by lossy compression? Available evidence points in the opposite direction. When dealing with complex systems of tens of thousands of tokens, the very same big mode predicted highly accurate conformations, with TM-scores reaching as high as 0.997; only when the scale was pushed to tens of thousands of residues did collapsed structures with scores dropping to 0.08–0.14 emerge. The sole variable was how far the input scale deviated from the training distribution, not whether an optimization mode was enabled. To be sure, the report did not run an unoptimized baseline at the same scale, so this attribution remains a reasonable deduction. As the technical report noted in its discussion: big mode extended the scale of systems the program could compute, but did not extend the knowledge learned by the model.
The real dividing line lies at the boundary of what the model itself learned. The maximum crop size sampled by AlphaFold3 during training was only 768 tokens, whereas the capsid systems that suffered collapse were, by residue count, roughly 40 to 90 times the size of those training crops. The optimized code runs directly on top of original weights; the spatial geometric relationships learned by the model hold true only within the scales it has seen. Beyond that regime, confronted with relative constraints across a sea of atoms, the conformations output by the model may be locally self-consistent, but globally they fold into physical nonsense. The report’s authors hypothesize that this reflects a failure of generalization on ultra-large systems, demonstrating that the crop size during training defines the learned boundary of the model and has nothing to do with the optimization code.
Would switching to the bitwise-identical exact mode make the collapse disappear? Within the normal distribution, the fast mode—which permits subtle numerical differences—is statistically indistinguishable from the original model in overall accuracy, with negligible degradation from optimization. And for ultra-large systems, the report provides a counterexample: while some samples in the stress tests omitted recycling steps, which the report acknowledges might affect results, one sample was run with full recycling enabled and experimental templates provided, yet the structure collapsed just the same. Protocol simplifications may have contributed, but they clearly cannot bear the full explanation.
A more practical constraint lies in hardware memory. The bitwise-identical exact mode is far more memory-intensive, with peak usage sometimes reaching more than 3x the original baseline. For structures with tens of thousands of residues, single machines can only fit them into memory by relying on big mode’s chunking and multi-GPU sharding; exact mode cannot even launch at this scale. Believing that switching back to exact mode would prevent collapse has neither been empirically verified nor is currently testable on a single node. The technical report likewise ran no cross-node controls of the unoptimized stock model at comparable scales. The attribution of this collapse remains, for now, a well-reasoned deduction.
The second boundary appeared in generative protein design tasks. Anthropic previously organized a multi-agent campaign in its August protein design report with a compute ceiling of approximately 2,500 H100 GPU hours per target. In this new round of controlled experiments, the workflow was substantially simplified: a single Claude instance directly drove the optimized model via CLI, running continuously on a single H200 GPU for 24 hours. The new and old approaches differed in compute budget by roughly 100x, while the actual wall-clock runtime for both campaigns was 24 hours. Supported by the new setup, the median candidate scores across targets for three models reached 0.785 (Opus 5), 0.781 (Mythos 5.1), and 0.739 (Mythos 5), respectively, compared to the 0.749 level of the previous campaign, with Mythos 5’s 0.739 falling slightly below the previous campaign’s median; the top scores averaged across targets reached 0.833, 0.825, and 0.813, respectively, with the first two outperforming the previous campaign’s 0.817, and Mythos 5’s 0.813 slightly below.
The metric used here to evaluate binding interfaces is called ipSAE, a computational confidence score ranging from 0 to 1 that reflects only the algorithmic model’s confidence in the spatial binding conformation, not the wet-lab success rate in a test tube. None of the novel protein molecules designed via the new workflow have yet been tested in physical laboratory experiments. The report’s text maintains strict discipline regarding attribution, noting that design outcomes do not isolate the contributions of the optimized models from those of the simplified protocol; furthermore, regarding the comparison groups with and without accelerated tools, it emphasizes that performance differences between accelerated and unaccelerated conditions cannot be attributed solely to the accelerated models themselves.
Looking at the progression of the overall project, it offers the technical community a high-certainty, low-risk paradigm for applying artificial intelligence. In my view, what is truly illuminating about this exploration is how clearly it delineates the division of responsibilities between engineering refactoring and scientific discovery, which matters far more than merely parading a few eye-catching speedup numbers.
At the frontier of real natural science, the physical cost of validating a new hypothesis is exceptionally steep. A molecular hypothesis lacking empirical grounding often requires months of laboratory effort to procure reagents, culture cells, and carry out tedious biochemical assays; if an algorithm produces hallucinations at the scientific level, it wastes tremendous research resources. Optimizing scientific software follows an entirely different risk calculus. This work altered code execution paths and memory scheduling without touching the mathematical formulations the tools use to derive scientific conclusions.
Software engineering has test suites and numerical baselines as safety nets. After code modifications were completed, the team verified logical correctness through unit tests, checked for numerical drift via bitwise comparisons, and calibrated overall accuracy distributions through large-scale testing across thousands of model-target pairings. If the model produced code hallucinations or if changes violated numerical constraints, automated assertions raised errors immediately, surfacing and resolving most technical mistakes during development.
This practice also reshapes the maintenance cost structure of scientific software. Academia has accumulated a wealth of ingeniously conceived open-source computational models, but constrained by human resources, these often lack sustained low-level engineering maintenance after papers are published. If the community relies solely on highly compensated systems hardware experts to hand-tune them one by one, the broader research ecosystem can hardly bear the exorbitant cost in time and capital. Two biomolecular modeling practitioners guiding a general-purpose model to overhaul more than 30 tools in four weeks demonstrates that large language models are capable of acting as high-caliber code refactoring assistants, transforming what was once an expensive optimization task reserved for a handful of specialists into scalable engineering with low marginal cost.
While faster computational tools certainly lower R&D overhead, smooth computation can never be equated directly with scientific breakthroughs. To further verify the actual biological activity of these computationally generated molecules, Anthropic has partnered with a biotechnology organization to launch a protein design competition. Targeting five frontier biological challenges, the initiative plans to perform wet-lab synthesis and physical activity assays on more than 5,000 computationally designed molecules submitted by the community. Until real biochemical assay data arrive, maintaining prudent objectivity remains the proper peer stance. Putting general-purpose models onto an engineering track safeguarded by rigorous test suites, allowing them to focus on the tedious heavy lifting of software renovation, is perhaps the most reliable and grounded path for artificial intelligence to serve scientific discovery at this stage.