Protein → Cell

Stage 1 — Sequence → Structure

Takes a sequence (protein, or a complex: protein+protein, protein+ligand, protein+nucleic acid) and predicts a static 3D pose. The AlphaFold2/3 lineage. Every repo here outputs coordinates, not motion — the shared limit the rest of the pipeline exists to fix.

How it's handled now

A 2026 pipeline treats structure as a swappable commodity stage. Boltz-2, Chai-1, Protenix and OpenFold3 have converged on near-identical complex specs, so one normalized input fans out to several models. The real cost is the MSA (multiple-sequence alignment), not the model — teams run it once, cache it, feed every model the same alignment, or go MSA-free (ESMFold, Chai single-seq) when speed beats a few points of accuracy. Because Boltz/Chai/Protenix are all MIT/Apache and commercial-clean, teams ensemble 2–3 of them and keep the best pLDDT/PAE pose rather than bet on one. Boltz-2 is the pivot: structure and a binding-affinity score in one run.

Where it breaks

You leave Stage 1 with a beautiful corpse — one frozen crystal-like pose. A protein is a distribution at 310K; function often lives in excited states it never shows. No dynamics, no thermodynamics, no kinetics. Disorder (~30% of the proteome) returns as low-pLDDT spaghetti people wrongly delete. Confidence lies exactly where it matters — allostery, cryptic pockets, point-mutation effects. AF3's affinity outputs are learned correlations with no energy underneath.

How to make it simpler

Each repo is a Python monorepo with its own conda env, CUDA pins, weight-download dance and bespoke output layout. The stage is conceptually one function — sequence → coordinates — buried under a dozen setup steps. A single Rust CLI can own the ugly parts: resolve/pin the model (Boltz-2 default: MIT, commercial-safe), one input schema compiling to whichever backend's YAML (--model boltz2|chai|protenix|openfold3), cache/reuse one MSA (or --no-msa), and normalize every backend's pose to canonical mmCIF + a small JSON sidecar. Heavy math stays in the model containers; Rust makes the stage one reproducible command.

The repos

Stage 2 — MD engines + ML force fields

Takes Stage 1's frozen pose and moves it — integrate Newton's equations, get a trajectory. Two knobs: the integrator (the MD engine) and the forces (classical force field vs neural potential).

How it's handled now

Velocity-Verlet at a ~2 fs timestep (4 fs with hydrogen-mass repartitioning), Langevin/Nosé–Hoover thermostat, SPME Ewald for long-range electrostatics, GPU via CUDA. GROMACS is the throughput workhorse; OpenMM is where new methods land. The 2026 shift is ML interatomic potentials (MACE/MACE-OFF, NequIP/Allegro, Orb, UMA) — near-DFT accuracy with open, downloadable weights — dropped into OpenMM via openmm-ml or served by torchmd-net.

Where it breaks

The MLIP weights are open; the runtime is the moat. Inference runs in Python/PyTorch/JAX and is 10–100× slower than classical force fields, with per-step Python overhead dominating — the accuracy is there, the speed is not. Setup (topology, atom typing, protonation, solvation) is fragile glue that breaks silently. And the timestep is capped by the fastest bond vibration, so reaching 1 ms = 10⁹–10¹² steps — the wall of Stage 3.

How to make it simpler

The stack is fast physics wrapped in slow Python glue. Two standalone, cargo add-able wedges: (1) a Rust neural-potential inference kernel (Candle/burn) that keeps data resident on GPU and fuses the message-passing kernels — the exact CPU↔GPU-copy-every-step bug that David-OConnor/dynamics admits about its own classical kernel; (2) a deterministic Rust setup tool (PDB → atom typing + protonation + solvation + FF assignment) to kill the silent-failure surface.

The repos

Stage 3 — The timescale gap (the hard wall)

MD reaches ns–µs (ms only on D.E. Shaw's Anton ASIC). Biology — folding, allostery, catalysis, gating — lives at ms → s → minutes, 3–9 orders past routine MD. It's a wall, not a slope: cost is exponential in barrier height (Kramers/Arrhenius). 100× more GPUs buys two orders of linear wall-clock against an exponential need. Brute force loses.

How it's handled now

Three families patch around it, each trading a different thing:

Where it breaks — and why MSM is the clean wedge

The whole live MSM world is one maintained Python library (deeptime) plus a graveyard of archived predecessors (PyEMMA, MSMBuilder, msmtools). The math — TICA (a generalized symmetric eigenproblem C(τ)v = λC(0)v), k-means/regspace clustering, reversible transition-matrix MLE, PCCA+ — is published and small. deeptime is in-memory, single-machine, scipy-bound; it wants the whole trajectory set in RAM. But mdCATH is 3.3 TB and Folding@home is many TB — today you can't MSM the big open datasets on a workstation.

How to make it simpler

A streaming Rust MSM/TICA/clustering builder: out-of-core TICA (Welford covariance) + streaming mini-batch k-means + transition counting — the covariance accumulation and counting are embarrassingly streamable. One binary ingests trajectory frames → emits metastable states + rate matrix + implied-timescale plot. No Python, no notebook, no AI-glue. And a ready test oracle already exists: mdshare serves the alanine-dipeptide set every deeptime tutorial uses, so the Rust builder validates its eigenvalues/timescales against deeptime's published outputs on the same input (to numerical tolerance — different eigensolvers won't match bit-for-bit). Correctness is checkable without a single experiment — the moat is speed, and speed is verifiable.

The repos — sampling, MSM, coarse-graining

Public trajectory datasets — the fuel

Stage 4 — Protein → Interactions (docking + affinity)

Given the structure, predict how it binds — the ligand pose, and the binding constant. This is the drug-discovery funnel.

How it's handled now

A funnel: AF3/Boltz-2/Chai fold the complex → Vina/gnina/DiffDock/DynamicBind pose the ligand → OpenFE/FEP (or Boltz-2's affinity head) rank the survivors. Boltz-2 is the 2026 shift — structure and a learned affinity in one pass, collapsing two stages.

Where it breaks

Docking gives poses, not affinities — scoring is the weakest link in all of drug discovery. Boltz-2's affinity is a correlation, not a computed ΔG, so FEP still guards the "real number." And FEP is a Stage-3 problem in disguise: its accuracy is bounded by sampling convergence, so slow binders / induced fit produce silent non-convergence. Cryptic pockets are Stage-3 rare events invisible to a static pose. ML potentials (MACE-OFF, Orb) are the credible path to physics-grade affinity — weights downloadable — but the slow Python runtime is, again, the block.

How to make it simpler

The honest read: the field is drowning in orchestration Python and starved of fast native runtime. The same MSM/kinetics and neural-potential kernels from Stages 2–3 are the simplification here — cryptic pockets and induced fit are rare-event sampling problems, and physics-grade affinity is a fast-inference problem. Don't rebuild the scorers; build the runtime the scorers should call.

The repos

(Boltz, OpenMM, GROMACS, PLUMED, MACE, Orb recur here from earlier stages — the funnel reuses the same engines.)

Stage 5 — Molecule → Pathway → Cell (systems biology)

Compose interactions into a network and simulate the cell's behaviour — ODEs when copy numbers are high, exact Gillespie SSA (+ tau-leaping) when they're low.

How it's handled now

libRoadRunner is the fast SBML engine; COPASI/basico and Tellurium wrap it for humans; BioNetGen/PySB handle rule-based combinatorial networks. Whole-cell splits into two camps: mechanistic (wcEcoli, E-Cell, Vivarium — hand-assembled, organism-specific) and ML virtual-cell (Arc STATE, scGPT, Geneformer, CZI — interpolate transcriptomics).

Where it breaks — the guarded core

The universal wall is not the solver — it's the rate constants nobody published. A 50-species model needs 100+ params (kon, koff, kcat, Km); most were never measured, the rest measured in vitro under conditions that don't hold in-cell. Parameter inference is an under-determined inverse problem — sloppy / structurally non-identifiable: many parameter sets fit the same data. SABIO-RK (300k+ params) and BioModels give a fraction of the numbers, never the whole set. And the ML virtual-cell camp does not simulate biophysics — it interpolates transcriptomics with no idea what a protein's structure is doing; its real moat is proprietary Perturb-seq/imaging data (Recursion, Insitro, Ginkgo), unrecoverable without a wet lab.

How to make it simpler

A Rust exact-Gillespie / tau-leaping core with a structural-identifiability front door: fit a CRN to time-series and report which parameters are non-identifiable from the data rather than faking a fit. The simplification is not "solve the params" (math forbids it) but "tell the user honestly what's fittable" — which no mainstream tool foregrounds.

The repos

Kinetic-parameter data (not code): SABIO-RK (300k+ reaction-kinetic params, REST API) and BioModels (SBML repository — publishes topology, hides the numbers).

The gap to build

The RSX edge wasn't the biggest market — it was a specific gap only you saw, exploitable alone. The biotech analogue must be guarded (someone hoards it), recoverable (physics + public tools + public data reconstruct it), and a solo wedge (a standalone artifact useful to non-you users day one). The 2026 finding that reframes everything: the models are less guarded than the folklore says. STATE ships open weights; the Virtual Cell Atlas is CC0; MACE-OFF/Orb weights are downloadable; SABIO-RK holds 300k+ params. So "the crown jewel is proprietary weights" is mostly wrong. The guarded-and-recoverable thing is speed, not data.

The honest catches — where it is NOT solo-buildable

The virtual-cell forward model itself needs the wet-lab Perturb-seq data moat (Recursion ~50PB, Insitro, Ginkgo). You cannot generate 100M perturbed cells without a wet lab — don't race Arc/pharma on their data. Fails the solo-wedge leg.

New force-field training data needs DFT clusters you lack — recover the kernel, not the dataset.

Some kinetic rates are non-identifiable from any public time-series by math, not secrecy — your tool must report that honestly, not fake a fit.