Skip to content

AlphaGenome

AlphaGenome predicts how a variant changes the human (hg38) or mouse (mm10) tracks you select, such as ATAC, DNase, RNA-seq or splicing, in the tissues you name. Altar calls Google DeepMind's hosted AlphaGenome API, one call per variant, from the altar process. It needs an API key and no GPU.

Kind Inline model calling a hosted API; type = "ALPHAGENOME"
Install pip install altar-alphagenome (PyPI)
Genome builds hg38, mm10, set by organism
Variant classes Every class: SNVs, MNVs, insertions and deletions
Compute Runs in the Altar process and calls a hosted API; no GPU. Needs ALPHAGENOME_API_KEY
Validation Not validated (Validation)
Licence Apache 2.0 SDK; the API's terms of use (non-commercial)
Upstream Code, Paper, Preprint, Documentation

When to use it

  • Use AlphaGenome to compare a variant's predicted effect across many assays from one model: accessibility, histone and transcription factor ChIP-seq, CAGE, RNA-seq, splicing and contact maps, in the tissues and cell types you name. It scores every variant class, in human or mouse.
  • It needs no GPU, weights or Docker. Each variant is one API call with your key, and the API suits analyses of thousands of predictions (Compute and scale).
  • Choose a model that runs from fixed weights, such as Cherimoya, ChromBPNet, Enformer or Borzoi, when results must be reproducible, or when a cohort is larger than the API's quota allows.
  • Free use of the API is limited to non-commercial research, and its outputs must not be used for clinical decisions (Cite and licence).

Add it to a run

[models.alphagenome]
type = "ALPHAGENOME"

[models.alphagenome.configuration]
credential = { provider = "env", name = "ALPHAGENOME_API_KEY" }
  1. Install the binding: pip install altar-alphagenome.
  2. Get an API key and export it before the run:

    export ALPHAGENOME_API_KEY=...
    
  3. Choose the scorers and the tissues (Choose tracks), and add them to the section:

    [models.alphagenome]
    type = "ALPHAGENOME"
    
    [models.alphagenome.configuration]
    credential = { provider = "env", name = "ALPHAGENOME_API_KEY" }
    ontology_terms = ["UBERON:0002107"]   # liver; narrow the tracks to your tissues
    scorers = ["ATAC"]
    

The spec needs no [backend] or reference FASTA. The key never enters the spec, the run summary or a stored identity. Give a hosted model its credentials covers credentials for every hosted model.

altar models alphagenome lists the six primary columns, the track_scores detail table, the configuration fields and the variable the spec names for the key. Score variants with a model walks through a run. Tutorial 2: add hosted predictions from AlphaGenome calls this model for five variants in a notebook.

Outputs

Column Type Meaning Units and reading
top_output_type str Output modality of the largest raw effect an output type, such as ATAC or RNA_SEQ
top_track str Track name of the largest absolute raw effect the track's name
max_abs_raw_score float Largest absolute raw variant score across returned tracks the scorer's raw units; no sign
top_track_abs_quantile_score float Absolute calibrated quantile score for the track with the largest absolute raw effect 0 to 1; from the same track as max_abs_raw_score
max_abs_quantile_score float Largest absolute calibrated quantile score across returned tracks 0 to 1; may come from another track
n_tracks_scored int Number of tracks with a raw score count; equals the variant's track_scores rows

The API returns scores for many tracks per variant. Altar keeps the tracks whose ontology_curie is one of the configured ontology_terms, and reduces them to one primary row per variant. The top track is the kept track with the largest absolute raw score. top_track_abs_quantile_score comes from that same track, while max_abs_quantile_score is the largest over every kept track.

A variant whose kept tracks have no raw score is stored with n_tracks_scored 0 and null scores.

track_scores

A detail table, version 0.0.2: Lossless AlphaGenome tidy scores, one row per variant, scorer, genomic track, gene, and splice junction

Column Type Meaning
scored_interval str AlphaGenome scored_interval
gene_id str AlphaGenome gene_id
gene_name str AlphaGenome gene_name
gene_type str AlphaGenome gene_type
gene_strand str AlphaGenome gene_strand
output_type str AlphaGenome output_type
variant_scorer str AlphaGenome variant_scorer
track_name str AlphaGenome track_name
track_strand str AlphaGenome track_strand
assay_title str AlphaGenome assay_title
ontology_curie str AlphaGenome ontology_curie
biosample_name str AlphaGenome biosample_name
biosample_type str AlphaGenome biosample_type
biosample_life_stage str AlphaGenome biosample_life_stage
gtex_tissue str AlphaGenome gtex_tissue
data_source str AlphaGenome data_source
endedness str AlphaGenome endedness
genetically_modified str AlphaGenome genetically_modified
transcription_factor str AlphaGenome transcription_factor
histone_mark str AlphaGenome histone_mark
junction_start int Start coordinate of the splice junction a SPLICE_JUNCTIONS score describes, as AlphaGenome reports it; null for other scorers
junction_end int End coordinate of the splice junction a SPLICE_JUNCTIONS score describes, as AlphaGenome reports it; null for other scorers
raw_score float Raw AlphaGenome variant score
quantile_score float Calibrated AlphaGenome quantile score

The reduction loses detail, so Altar also keeps the track_scores detail table: one row per variant, scorer, track, gene and splice junction. The metadata columns carry the fields of the SDK's tidy scores, such as the biosample and assay. junction_start and junction_end are set by the SPLICE_JUNCTIONS scorer only. A track returned without a raw score has no row. Read it as Read a run's results describes.

Configuration

Field Type Default Meaning
model resource { uri = "alphagenome://hosted" } The hosted model. Only the default, alphagenome://hosted, is accepted: Altar always calls the production model trained on all folds.
credential secret not set Where to read the API key, such as { provider = "env", name = "ALPHAGENOME_API_KEY" }. The key itself never enters the configuration.
ontology_terms list of text [] The tissues and cell types whose tracks to keep, as ontology CURIEs such as UBERON:0002107. Empty keeps every track.
scorers list of text [] The SDK's recommended variant scorers to call, such as ATAC or RNA_SEQ. Empty calls every scorer recommended for the organism.
sequence_length integer 1048576 Length in bases of the sequence the model reads, centred on the variant: 16384, 131072, 524288 or 1048576.
organism one of "HOMO_SAPIENS", "MUS_MUSCULUS" "HOMO_SAPIENS" The organism: HOMO_SAPIENS scores hg38 variants, MUS_MUSCULUS mm10 variants.

Fields go under [models.<name>.configuration]. Altar checks them when it builds the configuration, before any API call.

  • credential: provider = "env" is the only provider altar run reads.
  • scorers: keys of the SDK's RECOMMENDED_VARIANT_SCORERS. An unknown name fails with the list of valid names. POLYADENYLATION is for human only.
  • ontology_terms and scorers are stored sorted and without repeats, so their order does not change the model instance.
  • model takes no revision or digest. The binding always calls the production model trained on all folds.

Inputs

  • Genome builds: hg38 for organism = "HOMO_SAPIENS" (the default), mm10 for "MUS_MUSCULUS".
  • Variant classes: every class.
  • Reference: none. The hosted API supplies the sequence. A spec's [variants] reference_fasta is used by the annotation sources and is not passed to AlphaGenome. It does not change AlphaGenome's scores or identity.
  • ontology_terms: when a term matches none of a variant's tracks, the run logs one warning per batch that names it. A misspelled term keeps no tracks, so every variant is stored with n_tracks_scored 0.
  • sequence_length: 16384, 131072, 524288 or 1048576 (the default) bases, centred on the variant.

Where it comes from

AlphaGenome has no weights to fetch and no runtime image. The binding pins the alphagenome SDK at 0.9.0 and refuses to run with another version. It always calls the production model trained on all folds (ALL_FOLDS), and records that choice and the SDK version in the runtime identity.

A model instance is AlphaGenome plus its organism, ontology terms, scorers and sequence length. A liver ATAC configuration and a blood RNA-seq configuration are different model instances on the same endpoint. The provider names the production model rather than pinning its bytes, so hosted results are less reproducible than those of a model that runs from fixed weights.

Choose tracks

Two fields choose the tracks: scorers chooses the kinds of prediction, and ontology_terms the tissues and cell types.

Each scorer is a key of the SDK's RECOMMENDED_VARIANT_SCORERS. The SDK installs with the binding, so this lists them without an API key:

from alphagenome.models import variant_scorers

for name, scorer in variant_scorers.RECOMMENDED_VARIANT_SCORERS.items():
    print(name, scorer)
ATAC CenterMaskScorer(requested_output=ATAC, width=501, aggregation_type=DIFF_LOG2_SUM)
CONTACT_MAPS ContactMapScorer()
DNASE CenterMaskScorer(requested_output=DNASE, width=501, aggregation_type=DIFF_LOG2_SUM)
CHIP_TF CenterMaskScorer(requested_output=CHIP_TF, width=501, aggregation_type=DIFF_LOG2_SUM)
CHIP_HISTONE CenterMaskScorer(requested_output=CHIP_HISTONE, width=2001, aggregation_type=DIFF_LOG2_SUM)
CAGE CenterMaskScorer(requested_output=CAGE, width=501, aggregation_type=DIFF_LOG2_SUM)
PROCAP CenterMaskScorer(requested_output=PROCAP, width=501, aggregation_type=DIFF_LOG2_SUM)
RNA_SEQ GeneMaskLFCScorer(requested_output=RNA_SEQ)
RNA_SEQ_ACTIVE GeneMaskActiveScorer(requested_output=RNA_SEQ)
SPLICE_SITES GeneMaskSplicingScorer(requested_output=SPLICE_SITES, width=None)
SPLICE_SITE_USAGE GeneMaskSplicingScorer(requested_output=SPLICE_SITE_USAGE, width=None)
SPLICE_JUNCTIONS SpliceJunctionScorer()
POLYADENYLATION PolyadenylationScorer()
ATAC_ACTIVE CenterMaskScorer(requested_output=ATAC, width=501, aggregation_type=ACTIVE_SUM)
DNASE_ACTIVE CenterMaskScorer(requested_output=DNASE, width=501, aggregation_type=ACTIVE_SUM)
CHIP_TF_ACTIVE CenterMaskScorer(requested_output=CHIP_TF, width=501, aggregation_type=ACTIVE_SUM)
CHIP_HISTONE_ACTIVE CenterMaskScorer(requested_output=CHIP_HISTONE, width=2001, aggregation_type=ACTIVE_SUM)
CAGE_ACTIVE CenterMaskScorer(requested_output=CAGE, width=501, aggregation_type=ACTIVE_SUM)
PROCAP_ACTIVE CenterMaskScorer(requested_output=PROCAP, width=501, aggregation_type=ACTIVE_SUM)

Each line names the output a scorer reads and, for some scorers, the window around the variant in bases (width) and how it aggregates the tracks (aggregation_type). The AlphaGenome documentation describes each scorer. An empty scorers calls every scorer recommended for the organism.

ontology_terms keeps the tracks whose ontology_curie is in the list, such as UBERON:0002107 for liver. The API returns every tissue and cell type, and Altar narrows them after the call, so the choice does not reduce quota use. An empty list keeps every track. To see which terms a scorer covers, score a few variants with an empty ontology_terms and read the ontology_curie and biosample_name columns of track_scores. Each term set is a separate model instance, so that exploratory run stores its scores under its own identity.

Compute and scale

  • No GPU, no Docker and no [backend]. The altar process needs network access to the API.
  • Each variant is one API call. altar run keeps at most four calls in flight at once.
  • Quota: the API is free for non-commercial use, and query rates vary with demand. Google DeepMind describes it as suited to analyses of thousands of predictions, and likely not to more than a million. Larger or commercial use is offered through Google Cloud. See the AlphaGenome repository.
  • Failed calls: when a call fails, Altar logs a warning naming the variant and the error. That variant gets no rows, and the rest of the batch is stored. The next run finds it missing and calls again. When every call of a batch fails, the batch raises the first error.
  • Caching: a stored variant with n_tracks_scored 0 counts as done, so later runs do not call the API for it again.

Prioritization

A variant is prioritized when max_abs_raw_score >= 0.5 and top_track_abs_quantile_score >= 0.9. Both values describe the same track. This is a screening rule, not a calibrated threshold. Calibrate it for your cohort and question before you rely on it.

max_abs_quantile_score, the maximum over all kept tracks, can approach 1 even for unremarkable variants, so the rule does not use it. Narrow ontology_terms to the tissues that matter. What prioritized means explains how rules combine.

Validation

Validation label: Not validated. AlphaGenome is a hosted API, and Altar has no validation record for it. Altar's tests check the reduction and the detail table against synthetic results in the SDK's format, with no API call.

Not validated:

  • any comparison of Altar's stored scores with scores from the AlphaGenome SDK or its notebooks;
  • the live API's behaviour over time (Where it comes from).

The validation status table lists every model.

Limits

  • Results depend on a hosted service: quota, availability, the provider's privacy policy and its model versions apply.
  • The primary row is a lossy reduction. Use track_scores for the full result.
  • Record the scorers and ontology terms with every result; they define the model instance.
  • The prioritization rule is a screening rule, not a calibrated threshold.

Cite and licence

The AlphaGenome repository asks you to cite the model's paper if you use AlphaGenome in your research. It asks you to cite the AlphaGenome Atlas preprint too if you use "AlphaGenome Atlas website, API or scores".

@article{avsec2026alphagenome,
  author = {Avsec, {\v{Z}}iga and Latysheva, Natasha and Cheng, Jun and Novati, Guido and Taylor, Kyle R. and
    Ward, Tom and Bycroft, Clare and Nicolaisen, Lauren and Arvaniti, Eirini and Pan, Joshua and Thomas, Raina and
    Dutordoir, Vincent and Perino, Matteo and De, Soham and Karollus, Alexander and Gayoso, Adam and
    Sargeant, Toby and Mottram, Anne and Wong, Lai Hong and Drot{\'a}r, Pavol and Kosiorek, Adam and
    Senior, Andrew and Tanburn, Richard and Applebaum, Taylor and Basu, Souradeep and Hassabis, Demis and
    Kohli, Pushmeet},
  title = {Advancing regulatory variant effect prediction with {AlphaGenome}},
  journal = {Nature},
  volume = {649},
  number = {8099},
  pages = {1206--1218},
  year = {2026},
  doi = {10.1038/s41586-025-10014-0}
}

@article{cheng2026alphagenomeatlas,
  author = {Cheng, Jun and Taylor, Kyle R. and Nicolaisen, Lauren and Pan, Joshua and Bycroft, Clare and
    Perino, Matteo and Ward, Tom and Hawkes, Gareth and Covill, Laura E. and Weilert, Melanie and
    Thomas, Raina W. and Latysheva, Natasha and Hirschmann, Maile J. and Chen, Xi Dawn and Beaumont, Robin N. and
    Chundru, V. Kartik and Weedon, Michael N. and Bourdareau, Simon and Chu, Hoyin and Hariharan, Dhavanthi and
    Kagohara, Thais and Ten{\'o}rio, Lucas and Ushigome, Yosuke and Shearer, Courtney A. and Ikica, Barbara and
    Fang, Ada and Naciri, Mouad and Johnston, Victoria and Green, Richard and Wong, Lai Hong and
    Dutordoir, Vincent and Mottram, Anne and Gayoso, Adam and Arvaniti, Eirini and Novati, Guido and
    Rehm, Heidi L. and Chen, Fei and Lareau, Caleb A. and Wright, Caroline F. and O'Donnell-Luria, Anne and
    Zeitlinger, Julia and Kohli, Pushmeet and Avsec, {\v{Z}}iga},
  title = {{AlphaGenome} Atlas: in silico mutagenesis of the entire human genome improves prioritization and
    interpretation of non-coding variants},
  journal = {medRxiv},
  year = {2026},
  doi = {10.64898/2026.09.16.26363192}
}
  • Terms: the API is subject to the AlphaGenome Terms of Service. Outside what those terms allow, its outputs are for non-commercial use only, must not be used to train other machine learning models, and must not be used for clinical decisions.
  • SDK: the alphagenome package is licensed Apache 2.0.
  • Runtime image: none.
  • Binding: altar-alphagenome is MIT-licensed. The API's terms apply independently of it.

Python and extension

AlphaGenomeConfiguration holds model, credential, ontology_terms, scorers, sequence_length and organism, and checks them when it is built, before any API call. The credential is a SecretReference. Models and plans is the API reference for the model interface it implements. The raw key, an injected scorer or an SDK client reaches the plugin only through AlphaGenomeRuntime, which is not part of the model instance's identity. Its max_concurrency (default 4) bounds calls in flight. build_scoring_plan returns an InlineScoringPlan, and execute_inline makes the calls. AlphaGenomeRunInputs.variants defaults to empty; batch preparation supplies the variants.

The result schema is version 0.0.2. A stored 0.0.1 primary row alone cannot be relabelled as 0.0.2: keep it under its original identity or score the variant again. In track_scores 0.0.2, junction_start and junction_end are part of the key.