AlphaGenome 2 Guide: What’s New, Benchmarks, Free API Setup and Limits

Google DeepMind has released AlphaGenome 2, and the big change is simple to say: it no longer guesses how a DNA change behaves “in the body” in general. It predicts what that change does inside one specific cell type or cell state, such as a gut macrophage or an activated T cell.

It launched on 11 November 2026 and you can use it today for free through the AlphaGenome API, as long as your work is non-commercial research.

This guide covers what changed from AlphaGenome 1, every benchmark DeepMind published, how to get a key and run your first variant score in Python, how to condition it on your own single-cell data, the limits, and how it compares with Evo 2, Borzoi and Enformer.

What AlphaGenome 2 Is (in Plain English)

Every cell in your body carries the same DNA, yet a liver cell and a brain cell behave completely differently. The difference comes from which genes each cell switches on, and how strongly.

Most disease-linked genetic variants sit in the “non-coding” 98% of the genome, in the switches rather than the genes. A variant can do nothing in one cell type and cause real trouble in another. That is the gap AlphaGenome 2 is built for.

You give it two things:

• A DNA sequence of up to 1 million letters (1 Mb), usually centred on a variant you care about.
• A condition: a tissue, cell type or cell state from DeepMind’s catalogue, or a profile built from your own single-cell experiment.

It returns predicted molecular readouts for that one condition, for both the reference and the altered sequence. The difference tells you whether the variant probably raises or lowers a gene’s activity in that cell.

Note: the team behind it is Adam Gayoso, Natasha Latysheva, Pushmeet Kohli and Žiga Avsec at Google DeepMind. A technical paper (PDF) was published alongside the blog post.

What Changed From AlphaGenome 1

AlphaGenome 1 arrived in June 2025 and was published in Nature in January 2026. It predicted thousands of tracks across many tissues at once. Version 2 flips that design.

The imputation part matters more than it looks. If your lab only measured gene expression, AlphaGenome 2 can predict readouts you never measured, such as chromatin accessibility. The imputation_mode label tells you how far to trust each one.

Benchmarks and Results

All numbers below are DeepMind-reported from the launch blog and paper. No independent replication exists yet, as the model is one day old.

The two case studies

• Inflammatory bowel disease: it reproduced a 2024 Nature finding, where a variant boosts the ETS2 gene specifically in gut macrophages.
• Severe COVID-19: it separated vaccine-activated T cells from resting ones, and showed a severe-COVID-linked variant disrupts gene activity more strongly in the activated state.

Tip: read the 30% figure carefully. It means the model still misses most causal variants on that test. Its value is a better shortlist for the lab, not an answer key.

Access, Price and Licence

Warning: DeepMind says predictions are for research only and are not validated for clinical or diagnostic use. Do not feed patient decisions with it.

How to Score a Variant in Python, Step by Step

This follows the official v2 “score a variant” notebook. Everything runs on DeepMind’s servers, so a laptop is enough.

1. Get a free API key. Go to alphagenome.google/api, sign in and accept the non-commercial terms.
2. Install the package. In a fresh virtual environment run pip install alphagenome (or uv pip install alphagenome).
3. Store the key. Export it as ALPHA_GENOME_API_KEY in your shell. In Colab, add it under Secrets with the same name and allow notebook access.
4. Check the setup. Create a client and call supported_conditions(). You should get a table with one row per condition.
5. Pick a condition, define the variant, score it. Use the code below.

import os
from alphagenome.data import genome
from alphagenome.models.v2 import dna_client, variant_scorers

dna_model = dna_client.create(os.environ["ALPHA_GENOME_API_KEY"])

# CD14-positive monocytes in blood (tissue CURIE + cell CURIE)
condition = "UBERON:0000178_CL:0001054"

variant = genome.Variant(chromosome="chr2", position=219243701,
                         reference_bases="C", alternate_bases="T")
interval = variant.reference_interval.resize(dna_client.SEQUENCE_LENGTH_1MB)

scorer = variant_scorers.RECOMMENDED_VARIANT_SCORERS["SC_GENE_EXPRESSION"]
scores = dna_model.score_variant(interval=interval, variant=variant,
                                 variant_scorers=[scorer], condition=condition)

df = variant_scorers.tidy_scores(scores, match_gene_strand=True,
                                 filter_protein_coding=True)
print(df.query('imputation_mode == "observed"')
        .sort_values("raw_score")[["gene_name", "track_name", "raw_score"]].head(10))

Each row of the tidy table is one variant, gene, scorer and track. In DeepMind’s own example, the gene GLB1L gets a raw_score of about -1.84 for this C>T change in monocytes.

How to find the right condition string

• Browse: dna_model.supported_conditions() returns every reference condition with a biosample_curie column.
• Format: composite conditions join CURIEs with an underscore (tissue_cell). A single CURIE or a ModelCondition object also works.
• Many tissues: v2 does one condition per call, so loop, or use the batch methods predict_variants / score_variants with conditions=.

New to Colab limits? Our Google Colab free tier guide explains sessions and timeouts. You do not need a GPU runtime here, since the work happens on the API.

Using Your Own Single-Cell Data

This is the headline feature. If your cell type is not in the catalogue, such as a disease state from your own experiment, you can describe it with your own cells.

1. Prepare an AnnData object. It must hold raw integer UMI counts (not normalised) with Ensembl gene IDs in var_names.
2. Keep it small. A few dozen cells is enough per DeepMind; the hard cap is 256 cells per call.
3. Swap the argument. Instead of condition=, pass cell_conditioning=your_adata plus a label in cell_condition_name=.
4. Request single-cell outputs. SC_GENE_EXPRESSION_DENOISED (per strand, in CPM) works under cell conditioning.
5. Compare states. Run the same variant with “resting” and “activated” cell sets to see where it bites, exactly like the COVID example.

Tip: want a cell profile without predicting anything? DnaClient.encode_cells returns the embedding the model builds from your cells.

Porting AlphaGenome 1 Code

Old notebooks will not run unchanged. The official migration guide lists these breaking changes:

• Import: from alphagenome.models.v2 import dna_client. The v1 client still lives at models.v1.
• A condition is now required for every predict and score call. v1 scored all tissues by default.
• Metadata: output_metadata() is replaced by supported_conditions() and observed_metadata(); ontology_curie became biosample_curie.
• Scores: quantile_score is gone. Build your own background distribution if you relied on it.
• Batch scoring: pass conditions= and variant_scorers= as keywords.
• Contact maps: values are not coarse-grained any more, so do not compare them directly with v1 numbers.

AlphaGenome 2 vs Evo 2 vs Borzoi vs Enformer

Pick AlphaGenome 2 when the question is “in which cells does this variant matter?”. Pick an open model like Evo 2 or Borzoi when data cannot leave your servers, or when you need millions of predictions.

Limits and What Is Still Unknown

• Research only: not validated for diagnosis or personal genome interpretation.
• No weights, no self-hosting: your sequences go to Google’s API. Check your ethics approval for patient-derived data.
• Throughput: rates change with demand; DeepMind says it is not suited to analyses needing over 1 million predictions. Use AlphaGenome Atlas lookups for bulk single-letter changes.
• One condition per call: scanning 300 cell types means 300 calls.
• Input quality: conditioning results depend on the quality of the cells you upload.
• Unknowns: parameter count, full architecture details, commercial pricing and a date for the Antigravity Skills are not published.

Troubleshooting

My Take

This is the most useful upgrade the AlphaGenome line could get. Geneticists rarely ask “does this variant do something?” They ask “where, and in which cells?”, and v1 answered that only roughly.

The “condition on a few dozen of your own cells” trick is the part I would watch. If it holds up outside DeepMind’s benchmarks, small labs studying rare cell states get a capability that used to require fine-tuning a model they could not afford to train.

Two caveats. The 30% vs 16% gain is measured partly against DeepMind’s own earlier model, and there is no open-weights version, so privacy-bound clinical groups are left out. Expect independent benchmarks in the next few months to settle how big the jump really is.

For more DeepMind research explained, see our breakdown of DeepMind’s AI finding weaknesses in 1024-bit RSA. Developers who prefer Google’s general models can start with our Gemini API Python tutorial, and the coming Antigravity Skills will plug into tools like Google Antigravity /swarm.

FAQ

Is AlphaGenome 2 free?

Yes, for non-commercial research. You need a free API key from alphagenome.google/api. Commercial use is in a private preview with no public price yet.

Can I download AlphaGenome 2 and run it locally?

No. The alphagenome Python package is only a client; predictions run on Google’s servers. The client code is Apache 2.0, but v2 model weights are not released.

Can I upload my own DNA test results?

It is not designed for that. DeepMind says it is not validated for personal genome prediction or clinical use, and consumer test files are not the input it expects.

Do I need a GPU?

No. The package runs on Linux, macOS or Windows without a local GPU, and Colab’s free CPU runtime works for the tutorials.

How many cells do I need for single-cell conditioning?

DeepMind says “just a few dozen cells” can be enough. Each call accepts up to 256 cells as raw UMI counts with Ensembl gene IDs.

Does it work for mouse?

Yes. It was trained on human and mouse data, and there is an official v2 Colab notebook for mouse predictions.

What is the difference between AlphaGenome 2 and AlphaGenome Atlas?

Atlas is a precomputed map of predictions for all 9 billion possible single-letter changes in the human genome. AlphaGenome 2 is the live model you query for a chosen sequence and cell condition.

Sources

• Google DeepMind: AlphaGenome 2 launch blog and technical paper (11 November 2026)
• AlphaGenome documentation: installation, getting started, AG1 vs AG2 migration guide, v2 score_variant notebook (alphagenomedocs.com)
• google-deepmind/alphagenome GitHub repository (licence, rate-limit notes)
• Google DeepMind: AlphaGenome 1 blog (June 2025) and AlphaGenome Atlas announcement
• The Neuron: “AlphaGenome 2 wants to find where disease begins” (11 November 2026)
• Nature (2024): ETS2 and inflammatory disease in macrophages