AlphaFold 2,
explained.

Rung 1 is given a graph and learns features on it. Here the structure is the output: the input is a one-dimensional amino-acid sequence and the target is the three-dimensional arrangement it folds into. There is no adjacency matrix to normalise, because which residues touch in space is exactly the unknown.

The change that makes it tractable is where the information is found. A single sequence is not enough, but the same protein in thousands of species is: if two positions are in contact, a mutation at one tends to be compensated by a mutation at the other, because the contact must be preserved for the protein to work. So a multiple-sequence alignment across evolutionary relatives carries a statistical shadow of the 3D contacts, and the model's job becomes reading structure out of coevolution. This is a data insight, not an architectural one, and it is the load-bearing part.

Two further choices are what turn a contact signal into coordinates. The network maintains two representations that talk to each other — one over the alignment and one over residue pairs — and updates the pair representation with operations built around triples of residues, so that the implied distances are pushed toward satisfying the triangle inequality. The geometry is enforced inside the attention rather than repaired afterwards. And the final module emits coordinates end to end, rather than predicting a contact map and handing it to a separate folding program, with a per-residue confidence that turned out to be calibrated — which is why it is arguably the most practically important number the system produces.

The protein-folding problem — predict a protein's 3D structure from its amino-acid sequence — was one of biology's great open challenges. Structure determines function: how an enzyme catalyzes, how a receptor binds a drug, how a mutation causes disease. But determining structure experimentally (X-ray crystallography, cryo-EM) is slow and expensive, taking months to years per protein, while sequences pile up by the millions. The dream was to skip the lab and compute the shape.

It resisted because the search space is astronomical and the physics is subtle — a chain can fold countless ways, and predicting the one it actually adopts from first principles is intractable. AlphaFold 2's breakthrough was to sidestep brute-force physics and instead learn from two rich sources of information: the evolutionary record of related proteins, and the accumulated experimental structures. Deep learning tied them together; evolution supplied the crucial constraints.

Here's the central biological insight AlphaFold exploits. Gather a multiple-sequence alignment (MSA): the same protein from many species, lined up position by position. Now look at two columns of that alignment — two residue positions. If those two residues are physically in contact in the folded structure, they're under a joint constraint: a mutation at one that would disrupt the fold tends to be accompanied by a compensating mutation at the other. So over evolutionary time, contacting positions coevolve — they mutate together.

That turns a structural question into a statistical one you can read off the alignment: columns that covary flag residues that touch. Measure the correlation between two columns across the family; high correlation predicts a contact.

A single sequence tells you nothing — covariation only appears across a family, which is why deep MSAs (thousands of related sequences) matter so much. This coevolution-to-contact idea predates AlphaFold, but AlphaFold learned to use it far more powerfully than hand-crafted statistics could. The runnable version below detects a covarying (contacting) pair of columns and shows a single sequence yields no signal.

AlphaFold 2's engine is the Evoformer, a deep stack of attention blocks — the same attention mechanism behind transformers, adapted to biology. It maintains and refines two coupled representations:

The clever part is the two-way flow: coevolution signals from the MSA sharpen the pair representation, and geometric constraints in the pair representation feed back to interpret the MSA. Iterated many times, this produces a pair representation that encodes, for every pair of residues, a rich prediction of their spatial relationship — the distilled structural knowledge that the next stage turns into actual coordinates.

The structure module takes the Evoformer's refined representations and predicts the 3D structure directly — not a contact map to be folded afterward, but the structure itself. It represents each residue as a frame (position + orientation), predicts torsion angles to place the side-chain heavy atoms, and uses invariant point attention, an attention variant that respects 3D geometry (the prediction is the same however you rotate or translate the whole protein). The whole pipeline is then recycled — its output fed back as input several times — to iteratively refine the structure.

Crucially, AlphaFold reports pLDDT, a calibrated per-residue confidence from 0 to 100. High pLDDT means the model is sure of that residue's position; low pLDDT flags uncertain regions, often genuinely flexible or disordered parts of the protein. That confidence is a practical gift: it tells a biologist exactly which parts of a predicted structure to trust, turning a prediction into a usable scientific tool rather than a black-box guess.

AlphaFold 2 (Jumper, Evans, Pritzel and colleagues at DeepMind) maps an amino-acid sequence to 3D coordinates for every heavy atom with one network trained end to end. The steps:

1. Search for relatives and templates. The input sequence is searched against large sequence databases (UniRef90, MGnify, BFD and Uniclust30, using jackhmmer and HHblits) to build a multiple sequence alignment (MSA), and against structures in the PDB to find up to four templates.
2. Embed two representations. The MSA representation holds one vector per sequence per residue (N_seq × N_res, 256 channels); the pair representation holds one vector per pair of residues (N_res × N_res, 128 channels), initialized from the sequence, relative positions and template features. Very deep alignments are subsampled, with an extra, cheaper stack reading many more sequences.
3. Run 48 Evoformer blocks. Each block applies, in order: row-wise attention over the MSA with a bias computed from the pair representation; column-wise attention across sequences; an MSA transition; an outer product mean that turns pairs of MSA columns into an update for the pair representation; two triangle multiplicative updates (outgoing and incoming edges); two triangle self-attentions (around the starting and the ending node); and a pair transition.
4. Build the structure. The structure module, 8 blocks with shared weights, treats each residue as a rigid frame (a rotation and a translation), all starting at the origin. Invariant point attention updates a per-residue representation using the pair representation and 3D points expressed in each residue's local frame, so the result does not change when the whole protein is rotated or moved. Each block updates the frames, and predicted torsion angles place the side-chain atoms.
5. Recycle. The outputs, including the predicted structure, are fed back as inputs and the whole network runs again; inference uses three recycling iterations. During training the number of iterations is random and only the last one is backpropagated, which keeps the cost manageable.
6. Train with several losses. The main loss is FAPE, on the final structure and on each structure-module layer, plus a distogram loss (binned inter-residue distances predicted from the pair representation), a masked-MSA loss (predicting randomly masked alignment entries, in the style of BERT) and a loss for the confidence head. Fine-tuning adds a penalty for physical violations such as clashes.
7. Self-distill. A first model predicted structures for roughly 350,000 diverse sequences from Uniclust30; the confident predictions were mixed with real PDB structures to train the final model.
8. Report confidence. pLDDT, a per-residue estimate of local accuracy from 0 to 100, comes from the structure module's representation. The predicted aligned error (PAE), from the pair representation, estimates for every pair of residues the position error at one when the structure is aligned on the other, and from it comes a predicted TM-score.

Training used PDB structures released before the end of April 2018, with chains cropped to a few hundred residues to fit in memory.

• Ti — the predicted frame of residue i (rotation and translation); xj — the predicted position of atom j; the superscript true marks the experimental structure.
• Ti^−1 ∘ xj — atom j as seen from residue i's local frame. Comparing these local views for every frame and atom makes the loss independent of where the whole protein sits in space, with no superposition step, while still telling a structure from its mirror image.
• dclamp, Z — errors are capped at 10 Å so a few wildly misplaced atoms cannot dominate, and the result is divided by 10 Å to make it unitless.
• zij — the pair representation for residues i and j; a, b, g — gated linear projections of the pair representation; ⊙ is elementwise multiplication.

The triangle update makes edge ij depend on the two other edges of every triangle ijk, which is how evidence that i is near k and k is near j reaches the estimate for i and j. At the extremes, a protein with no informative alignment gives these updates little to combine, and for long chains the sum over k, N_res^³ operations per channel, is among the most expensive parts of the Evoformer.

The headline test was CASP14 in 2020, a blind assessment in which structures were predicted before the experimental ones were released. The paper reports accuracy as r.m.s.d.₉₅, the root-mean-square deviation of Cα atoms (or of all heavy atoms) over the best-fitting 95 percent of residues.

For scale, a carbon atom is about 1.4 Å wide, so the median backbone error was smaller than one atom. To rule out a CASP-specific result, the authors also evaluated chains deposited in the PDB after the training cutoff and found the accuracy held, with pLDDT tracking the measured local accuracy closely enough to tell users which regions to trust.

The ablations changed one component at a time and retrained. Self-distillation, recycling, the triangle operations, invariant point attention and the masked-MSA objective each contributed, and no single trick carried the result. The clearest negative result concerns the input: accuracy fell sharply when the alignment held fewer than about 30 effective sequences, the orphan-protein case in which coevolution has little to say, while gains flattened at greater depths. Accuracy was also lower for chains whose shape depends on contacts with other chains, since the model saw one chain at a time; the AlphaFold-Multimer follow-up addressed complexes directly.

The dependency on evolutionary depth is stated, and it is the sharpest limitation: accuracy degrades where the alignment is shallow, which means orphan sequences, fast-evolving regions and de novo designed proteins with no natural relatives are exactly the hard cases. A method that reads evolution cannot help where there is no evolution to read.

Two more scope limits are explicit. The output is a single structure, not the ensemble of conformations a real protein moves through, so function that depends on motion is outside what is predicted. And complexes — several chains bound together, which is how most biology actually happens — were not the target and needed separate later work. The confidence score is what makes both survivable in practice, because a user can tell which parts of a prediction to trust.

How it held up: about as well as any result on this site. The benchmark margin was decisive rather than incremental, the released predicted structures changed day-to-day practice in structural biology, and the work was recognised with a Nobel Prize in Chemistry in 2024. The one claim worth handling carefully is the framing that the folding problem is "solved": the system predicts the outcome of folding without modelling the process, and those are different questions — one about a mapping, one about a mechanism. The papers are careful about this distinction in a way that much of the coverage was not.

AlphaFold 2 transformed structural biology and drug discovery, and it opened a wave of AI-for-science built on the same ingredients: AlphaFold-Multimer for complexes, AlphaFold 3 extending to proteins with DNA, RNA, and small molecules, and a broad "structure prediction" toolkit now standard in labs. It showed that deep learning could deliver not just useful predictions but scientific discovery.

Its deeper lesson is about where information hides. The structure a protein folds into isn't written explicitly anywhere you can read — but it's implicit in the evolutionary record, encoded in which mutations co-occur across millions of years and species. AlphaFold's genius was recognizing that a physics problem could be solved by learning to read that record, and building an architecture that could. Whenever a hard problem has left statistical fingerprints in abundant data, "learn to read the fingerprints" is a strategy AlphaFold made canonical.

Work each one out before you open it — a number, a prediction or a reason, not a definition. Producing the answer is what makes it stick. Your progress is kept on this device.

What to do when the data is a graph rather than a line of tokens — message passing, and the protein-folding system built on it.

1. 1Graph Neural Networks2017
2. 2AlphaFold 22021

All 110 papers, in 19 ladders →