Claude Makes Biomolecular Models Faster and More Memory-Efficient: Optimizing Scientific Tools, Not Only Using Them

On September 17, 2026, Anthropic published "How Claude is uplifting biomolecular modeling". The content is an engineering job: an internal general-purpose research model, working inside Claude Science, was pointed at the inference paths of the open-source models biologists use daily: structure prediction and cofolding, binder design, inverse folding, protein language models, genomics. More than 30 models, under four weeks, roughly 4x faster on average, and close to 2x when outputs must match the original implementation exactly.^[S1]

Two details are worth holding onto. The first is who supervised it: two members of Anthropic's technical staff experienced in biomolecular modeling but with no prior background in inference optimization or kernel engineering. The second is the shape of the delivery: not a paper plus a demo, but 36 drop-in optimization kits, one per upstream tool, published on GitHub, each offering three modes: exact (outputs identical to stock), fast (small numeric differences, usually the default) and big (lowest peak memory for large inputs).^[S1][S2]

Anthropic also announced a protein design competition co-sponsored with Adaptyv Bio: five frontier problems (species cross-reactivity, pH sensitivity, peptide-MHC specificity, and hard targets such as GPCRs), with wet-lab validation promised for more than 5,000 community-submitted designs, up to $1M in Claude credits, $250,000 in Modal compute and DNA from Twist Bioscience.^[S1]

The bottleneck is in the triangle operations

In structure models of the AlphaFold3, OpenFold3 and Boltz-2 family, most of the runtime and memory goes into two operations: triangle attention and triangle multiplication. They act on triplets of tokens, which is how the model expresses geometry, and they cost cubically in both time and memory: double the system and you pay eight times; triple it and you pay twenty-seven.^[S1]

Writing kernels is the standard way to cut that cost, and NVIDIA's cuEquivariance and later BioNeMo Inference Runtime exist for exactly this. FlashPairformer, built with Claude, is a set of custom kernels for those two operations: against that field standard it is 2.7-2.9x faster on triangle attention and 1.7-3.2x on triangle multiplication, depending on configuration. On top of that shared layer, Claude was pointed at each model for specific work: caching redundant recomputation, folding dead branches into their constant outputs. Together these make the structure-prediction models about 4x faster.^[S1]

The second piece is memory. The low-memory Big mode Claude created lets systems above 10,000 tokens be predicted accurately on a single GPU node. Machines folded this way include human mitochondrial complex I, the TRiC chaperone complex, a proteasome and a bacterial ribosome, each closely matching its experimentally determined structure. For scale, the 40S ribosome AlphaFold3 predicted accurately was 7,663 tokens.^[S1]

The same score, a hundredth of the compute

The clearest consequence of the optimizations shows up against Anthropic's own earlier binder-design work. That run gave Claude an approximately 16,000-word prompt, permission to spawn sub-agents, and up to $10,000 per target on Modal (roughly 2,500 H100 GPU hours) within 24 hours. The 2,500 hours is a spending cap, not measured use.^[S1]

This time the conditions were much tighter: a single Claude model, one H200, 24 hours of wall time, a prompt of about 1,100 words plus a reference sheet for pre-installed tools, no sub-agents and no human steering the designs. Three models (Mythos 5.1, Mythos 5 and Opus 5) ran against 16 targets, scored by ipSAE, an in-silico measure shown to be predictive of wet-lab binding. Averaged over the 16 targets, the median and top-scoring designs reach roughly the same ipSAE as the earlier campaign, using about two orders of magnitude fewer GPU hours: around $150 for GPUs and tokens combined. This compares two whole pipelines: the hardware (H100 to H200), the prompt, the agent setup (no sub-agents) and the design workflow all changed, and Anthropic itself attributes the result to the accelerated models combined with simplifications to its earlier design approach. It is not a roughly 100x kernel speedup under one configuration; the speedup from the kernels and per-model work is the ~4x average (near 2x with identical outputs) above.^[S1]

The scope of that sentence matters: what matches is the in-silico score, not a wet-lab hit rate. ipSAE correlates with experimental binding, but correlation is not equivalence, and no new experimental data accompanies this result.^[S1]

The role of a scientific agent moves one notch here. Most demonstrations so far have the model read the literature, pick candidates, call the tools and interpret results, with the tools taken as given. This one runs in a different order: find the bottleneck in the tool, change the implementation, check that the numbers still hold, then do science with the faster tool. In this site's framework that is also an Update, except what gets updated is the research stack rather than a hypothesis or a world model.^[S1]

Unit cost is an under-discussed variable in AI for Science. A binder-design pipeline going from a cap of about 2,500 GPU hours per target to 24 (a whole-pipeline comparison, not the kernels alone) may lower the barrier to this kind of computation; how many more labs can now afford it has not been surveyed. Folding a ribosome on one node takes a class of structural-biology problems off multi-node clusters. If this kind of optimization keeps going, a lot of progress may come not from new foundation models but from the falling unit cost of simulation, structure prediction, analysis and experiment planning.^[S1]

One more thing sets this apart from most lab claims: it is open. The 36 kits ship with their code, the baselines are NVIDIA's own implementations, and anyone can rerun the speedups on their own machine. The claim and the means to check it arrived together, which is not common in recent company releases.^[S1][S2]

The engineering half is checkable.

The speedups are measured against NVIDIA's cuEquivariance and BioNeMo-IR rather than a home-made baseline; the complex I, TRiC, proteasome and ribosome folded in Big mode are compared with experimentally determined structures; the code is open. This part outsiders can verify themselves, which is rare in a company release.^[S1][S2]

The larger systems run, but they do not come out right.

On viral capsids and protein compartments of 31,000 to 70,000 tokens, inference completes on a single 8-GPU B300 node but the predicted structures collapse. Anthropic states this plainly: those systems are nearly two orders of magnitude beyond the models' training context, and what moved is the memory wall, not the models' generalization.^[S1]

The protein-design conclusion is currently an in-silico score.

Reaching the earlier ipSAE level at about a hundredth of the GPU hours is a conclusion about whole-pipeline cost, not about hit rate. The Adaptyv competition promises wet-lab validation for more than 5,000 designs; only when that data lands does the cost chain connect to physical feedback.^[S1]

Kernel optimization is a task with a cheap referee.

Part of why this finished in four weeks is that the task is well posed: whether the output is right has a compiler and a numerical comparison as referee, and whether it is faster has a benchmark. Most scientific problems have no such referee, so an agent that can rewrite tools does not immediately imply an agent that can rewrite science.

Hit rates from the Adaptyv competition.

Wet-lab results for more than 5,000 community designs are the first real data connecting cheaper compute to more discovery. If hit rates hold as entrants' compute budgets shrink, the chain closes; if they do not, what got cheaper was screening rather than design quality.

Whether this travels beyond kernels.

The next thing worth watching is the same approach applied where verification is not cheap: experiment planning, data pipelines, choosing simulation parameters. There is no compiler to referee those, which is exactly what would test whether tool-rewriting is a general capability or a good fit for one well-posed class of task.