Each of the roughly three billion letters in the human genome admits three possible substitutions; the product of those two numbers is the nine billion rows the Atlas computed in advance and stored.
Each of the roughly three billion letters in the human genome admits three possible substitutions; the product of those two numbers is the nine billion rows the Atlas computed in advance and stored.

a petabyte of answers

Until this week, finding out what one changed letter of DNA does to the genes around it meant picking your variants, writing code, and running a slow, heavy model for hours. DeepMind ran it once for all nine billion possible single-letter changes and published the results, a petabyte of ready answers. But every variant ends up as a single score, and that score measures something you probably would not guess.

AlphaGenome has been available since January, and anyone with the patience and the hardware could run it. So what actually changed on 8 September? Nothing inside the model. What changed is how you reach the answer, and that one change is what makes this worth reading about.

What AlphaGenome does is compare a stretch of DNA against an altered copy of the same stretch and predict how the genes around it respond. Until this week you had to decide which changes you cared about, write code, and run a slow and expensive model on your own hardware. Now DeepMind has done that once for all nine billion possible single-letter changes and put the answers in a public repository that anyone can search without writing a line of code.

why you would ever enumerate all of it

Enumerating an entire input space is usually a bad idea, because most of that space never comes up. Human genetics is the rare case where the argument runs the other way, and the Atlas paper makes it in its own introduction: demographic models suggest that every variant compatible with survival already exists somewhere in the global population. So the nine billion rows are not a catalogue of hypotheticals. They are a catalogue of things real people are carrying right now. If you are going to have to score them all eventually, you may as well score them all once.

The second half of the argument is where the difficulty lives. Around 98% of human genetic variation falls in stretches of DNA that make no protein of their own. Those stretches are not idle; they decide which gene switches on, in which tissue, and how strongly. A broken gene is comparatively easy, because you can see the protein come out wrong. A change in a regulatory stretch shows itself only in some cells and only under some conditions. Carl de Boer, a genomicist at the University of British Columbia, puts it plainly: understanding how DNA changes affect this regulation is fundamental to understanding most disease.

follow the numbers

The human genome runs to about three billion letters. At each position, that letter can become one of three others. Three billion times three is nine billion. That is the entire derivation, and the headline figure turns out to be a multiplication rather than a claim.

The storage figure is the more interesting one. For each variant the model does not produce a number. It produces roughly 27,000 of them on average, because the same single letter has to be scored across hundreds of separate cell and tissue samples. Do the arithmetic yourself. At four bytes per number, one variant costs about 108 KB, and 108 KB times nine billion lands just under a petabyte, which is the figure quoted in the coverage. So the petabyte is not a boast either. It falls directly out of a single decision: how many tissues you insist on looking at.

Getting there was not free. Žiga Avsec, DeepMind's genomics lead, says the project looked computationally impossible when the team started, and early estimates put them about 80 times too slow to finish the batch in any reasonable time. Three things bought that factor: training a smaller model to imitate the large one, optimizing the code that runs directly on the GPU, and eliminating calculations that were being repeated for no reason.

this is an engineering decision, not a biological one

Anyone who has shipped a real system knows this pattern. When a function is expensive, its inputs are enumerable, and many people keep asking for the same inputs, you compute the answers once and put them in a table. It is a cache with the unusual property that it is prefilled and can never miss, because every possible input is already in it.

de Boer, who built a framework for comparing models of this kind, names the third condition almost word for word: the Atlas helps people without access to newer hardware, or simply stops dozens of groups from repeating the same simulation.

I have paid this bill. When you build a pipeline that reads a person's entire genome and produces a report from it, sequencing is no longer the expensive stage; interpreting every variant you find is. A precomputed table turns that stage from a heavy computation into a lookup, and that difference reshapes the architecture of the pipeline, not merely its cost line.

twenty-seven thousand numbers into one

Twenty-seven thousand numbers per variant is useless to a clinician and close to useless in a lab. So the team built a single score, called AVI, that sits on top of each row and states how likely the change is to matter.

How they built it matters more than the score does. Those 27,000 predictions are first reduced to ten features, one per assay type. Four protein-level features, two features comparing the human genome against hundreds of other species, and two simple indicators are added on top. That makes 18 features in total, and a neural network turns those 18 into the final number.

Why only 18? Because, as the paper states, the feature set was kept deliberately small so that each feature's contribution could be attributed cleanly. The 18 contributions sum to exactly the raw score, so any number you see in the Atlas can be pulled apart again and asked which part of it did the work. Shipping a scalar together with the means of decomposing it is the right way to ship a scalar, and whoever made that call understood the risk they were creating.

what that number actually measures

Here is the question that matters most. What was the score trained against?

AVI was trained to separate variants seen in more than one tenth of one percent of the population from variants seen less often than that. Operationally, "important" became "rare." The reasoning behind the substitution is old and sound: a genuinely harmful change is held down by selection, so it stays rare.

But it is a proxy, not the thing itself. The score answers how much a variant resembles the rare ones, not whether it will make you ill. Most of the time those two agree, and the results show it. AVI reaches the best available numbers on standard benchmarks, helped resolve a real case of rare childhood epilepsy, and raised the statistical power to find rare variants driving traits at population scale. Where the two come apart, though, the score is wrong quietly. Anything that has spread through a population lands on the harmless side by definition, because the training label comes from frequency and not from a patient's chart. de Boer's caution is exactly right: the score has a clear use and will also be easy to misread, because the system underneath it has a great many moving parts.

two walls the table does not cross

When it judges a variant, the model reads about one million letters around it. That window is wider than anything that came before, and it is still finite. Some stretches of DNA regulate a gene from much farther away and fall outside it.

Now set that limit beside the completeness of the table, because the combination is where the harm is. Every one of the nine billion variants carries a score, and no row is blank. A variant whose real mechanism sits outside the window therefore still gets a number, and that number comes out low. Low here means nothing was found inside the window, not that nothing is there. When a list is complete, its silence begins to look like testimony.

The second wall is arithmetic you can check yourself. Enumerability is a property of the question, not of the model. Nine billion is countable because only one letter moves. Ask about two letters moving together and the number of position pairs passes four billion billion; fold in the letter choices at each position and you arrive near 4 × 10^19. No petabyte holds that, and no 80-fold speedup rescues it. The uncomfortable part is that many diseases are not the work of a single variant at all, but of several acting together. The axis along which this table is complete is precisely the axis on which the biology is simplest.

what deepmind actually ships

Look at the pattern. In 2020, AlphaFold predicted three-dimensional protein structures and the results went into a public database. In 2023, AlphaMissense classified 71 million protein-altering variants as benign or pathogenic, and those results went into a public database as well. Now it is nine billion rows, together with 2,601 short patterns that mark where regulatory proteins bind and 253 billion places those patterns occur across the genome.

So the artifact that reaches the field is not the model. It is the table the model produced. The model is the factory and the table is the product, and that carries a consequence nobody discusses much. A table that becomes a public resource gets cited in papers, embedded in pipelines, and relied upon, and years later, when a better model scores the same variant differently, the citations stay exactly where they are. The model carries a version number. So does the table that came out of it; that one just never gets read.

Related articles