How research models run on GPUs: the journey of a Nadoo Bio job

How research models run on GPUs

What happens on a GPU server while you wait after pressing Run? Follow a structure prediction job through Nadoo Bio: preparing its input, finding space on a GPU, and making the completed files available on the results page.

Structure prediction, design, and docking jobs occupy portions of one GPU, with some space remaining

The models discussed here are structure prediction and protein design tools used in drug research. They help examine candidates computationally; actual effects require experimental confirmation.

Why models run on GPUs

Structure prediction models such as Boltz-2 divide inputs into tokens. A protein usually contributes one token per amino acid, while a ligand—a small molecule that binds a protein—contributes one per atom. The model calculates not only individual tokens but also a table of relationships between pairs of tokens. Doubling the number of tokens quadruples the number of pairs.

These calculations repeat similar multiplications and additions many times. GPUs, with thousands of processing units working in parallel, perform this work much faster than CPUs. The large tables must remain in GPU memory during calculation, however. If their memory requirements exceed available space, the requested configuration is difficult to run.

How memory grows with input size

Nadoo Bio measures GPU memory usage across input sizes to establish execution criteria for each tool. The measurements below were taken on October 1, 2026, using one NVIDIA RTX PRO 4000 Blackwell (24 GB), public structures PDB 1UBQ, 4HHB, 6M0J, and 6VXX, and their sequences.

A residue is an amino-acid unit in a protein chain. Memory is peak observed GPU usage in GiB, where 1 GiB equals 1,024 MiB. Time runs from container startup to confirmed termination, including preparation but excluding queue waiting. The measurements limited CPU allocation to four CPUs and system memory to 16 GiB.

Boltz-2 GPU memory rises to 2.6, 3.5, 6.6, 12.0, and 19.0 GiB at 100, 300, 600, 900, and 1,200 tokens; a dashed line near 23.9 GiB marks device capacity

Tool

Input

Peak GPU memory

Measured runtime

Boltz-2

100 tokens

2.6 GiB

22 s

Boltz-2

600 tokens

6.6 GiB

46 s

Boltz-2

1,200 tokens

19.0 GiB

2 min 5 s

ProteinMPNN

793 residues, 8 sequences

0.8 GiB

8 s

ProteinMPNN

2,916 residues, 100 sequences

2.9 GiB

4 min 38 s

RFdiffusion

275 residues

5.6 GiB

4 min 30 s

RFdiffusion

698 residues

15.8 GiB

11 min 10 s

RFdiffusion's 15.8 GiB and 11 min 10 s refer to an input totaling 698 residues on one RTX PRO 4000 Blackwell. This October 1, 2026 measurement includes initial preparation, not just GPU computation.

Boltz-2 was measured without an MSA and with one sample. An MSA is an alignment of related protein sequences. Including one or increasing the sample count changes the resource requirements.

Even on the same GPU, requirements differ substantially by tool and input.

  • Boltz-2: increasing tokens twelvefold, from 100 to 1,200, increased memory more than sevenfold. At 1,200 tokens, it used about 80% of the 24 GB GPU's memory.

  • ProteinMPNN, which designs sequences for a structure: with batch size fixed at 1, increasing the number of sequences generated from the same input from 8 to 100 did not increase peak memory in these measurements. Runtime increased instead.

  • RFdiffusion, which designs new protein backbones: memory and runtime grow rapidly with length. An 893-residue input reached the 15-minute limit in the initial measurement, but completed in 776 seconds—about 12 min 56 s—with a compilation cache the next day.

A cache allows GPU code prepared once to be reused. RFdiffusion spent substantial time on this preparation, and caching reduced it. The table records particular inputs and environments; it is not a runtime estimate for every job. It does not establish the cached runtime for the 698-residue input.

Measurements also inform guidance before execution. For example, Boltz-2 checks verified token and sample limits when a plan is created, and explains which settings to reduce if they are exceeded. It cannot predict every out-of-memory case, but guidance based on measured ranges reduces trial and error.

The journey of a job

Five stages: fix the plan, queue, worker pickup, isolated execution, and validation and publication

1. Fix the plan

An execution plan fixes the input files, settings, and tool version together. The version is identified by the content hash of a container image containing the execution environment, so another image with the same name but different contents cannot replace it. Only a human-approved plan is submitted.

2. Wait in the queue

Submitted jobs enter a queue. Submissions are accepted even when all GPU servers are busy, and jobs run as capacity becomes available. Execution-server status indicates whether a job can start now or must wait. Agents can obtain this information through list_execution_options.

3. A GPU-server worker picks up the job

Each GPU server runs a program called a worker. When it has capacity, it requests a job from Nadoo Bio. Jobs are pulled by available servers rather than pushed into busy ones. The Nadoo Bio server calculates a memory reservation from the tool and input size; the worker assigns the job to a GPU with sufficient space.

4. Run in an isolated container

Each job runs in an isolated container with resource and network restrictions defined by its execution profile. The measurements above used four CPUs and 16 GiB of system memory; other profiles can allocate different resources. The worker reports progress to the server. If contact is lost, the server checks the execution lease and handles the attempt as a platform failure. Recovery and credit settlement follow the execution path and current policy; a lost connection is not evidence that the calculation completed.

5. Validate and release the results

Each execution attempt writes to its own folder, so reruns do not mix files with earlier attempts. The server checks file hashes before making results available. The files can then be viewed on the results page or through an agent.

Sharing one GPU among several jobs

The small ProteinMPNN job in these measurements used less than 1 GiB of GPU memory. Assigning an entire GPU to such a job leaves much of its memory unused. For input ranges backed by measurements, Nadoo Bio reserves memory with headroom and allows other jobs to run when space remains. Jobs outside the measured range may receive a whole device.

Conceptual memory reservations for Boltz-2, RFdiffusion, and ProteinMPNN with spare space; segment sizes are not actual reservation amounts

The diagram illustrates memory sharing. Spare memory does not imply the same proportion of spare computing performance. Concurrent jobs can affect one another and take longer than isolated runs.

If free space is smaller than the job's reservation, the job waits until enough capacity becomes available. The execution-server display's largest available space on a single device represents this capacity.

Reading the result

A completed GPU job means the calculation has finished. Structural confidence measures indicate the model's confidence in its prediction; they do not guarantee binding or experimental outcomes. Repeating the same plan can produce slightly different results. Inputs and settings can be fixed, but the model's calculation includes randomness.

On the results page, examine structures and metrics before choosing candidates for further comparison. Nadoo Bio also retains the inputs and versions used for the calculation. Those records provide a starting point when revisiting the result. See Reading results for interpretation guidance.