Evo2¶

A multi-domain autoregressive DNA foundation model (1B--40B parameters) built on StripedHyena, supporting embedding extraction, log-probability scoring, and sequence generation across prokaryotic, eukaryotic, and viral genomes.

License: Apache-2.0 · Molecules: dna · Tasks: embedding, sequence_generation, property_prediction

Actions: encode, log_prob, generate · Variants: 1

At a glance¶

Use it when

You need to analyze or generate DNA sequences across all domains of life — prokaryotic, eukaryotic, and viral — with a single model
You need long-range genomic context (>12 kbp) for tasks like enhancer-promoter interaction prediction, whole-locus variant effect scoring, or multi-gene region analysis
You need DNA embeddings, log-probability scoring, and sequence generation from a single deployment for maximum pipeline flexibility
You are predicting variant effects in eukaryotic genomes (especially human clinical variants) where Evo 1.x's prokaryotic training bias would be a limitation (Evo2 is trained across all domains of life)
You need layer-selectable embeddings to experiment with different representation depths for your specific downstream task
You are designing synthetic DNA sequences that must be plausible across multiple domains of life, not just prokaryotes
You need genome-scale DNA generation for synthetic biology applications involving eukaryotic-style genomic organization

Strengths

Multi-domain training on 9 trillion nucleotides spanning prokaryotes, eukaryotes, and viruses — the broadest genomic training data of any DNA model in this catalog
Three-action API (encode + log_prob + generate) provides embeddings, fitness scoring, and sequence generation in a single model deployment
Up to 1M-token context (7B variant) enables genome-scale analysis including whole gene loci, long-range enhancer-promoter interactions, and multi-gene regions
Published demonstration of zero-shot BRCA1 pathogenic variant prediction with over 90% accuracy, validating clinical-relevance for eukaryotic variant effect prediction
Layer-selectable embedding extraction enables users to choose representation depth — shallow layers for local patterns, deep layers for long-range dependencies
Single-nucleotide (byte-level) tokenization preserves full sequence resolution without tokenization artifacts, enabling precise variant effect analysis
Multiple size variants (1B base, 7B base) provide a compute-quality tradeoff for different deployment scenarios
Apache-2.0 license permits unrestricted commercial and academic use

Limitations

Higher compute requirements than embedding-only models — the 1B variant requires an L4 GPU, and the 7B variant requires even more resources for long-context inference
Recent model (2025) with limited independent benchmarking beyond the original publication; less established than NT or DNABERT-2 for embedding tasks
StripedHyena architecture is less widely adopted than standard transformers, potentially complicating integration with existing downstream pipelines
Generated sequences require computational and experimental validation — the model provides statistical plausibility, not guaranteed function
Byte-level tokenization produces very long token sequences, resulting in slower inference per nucleotide compared to BPE (DNABERT-2) or 6-mer (NT) approaches
No built-in function conditioning for generation — cannot specify target gene function or regulatory activity during sequence design
Mechanistic interpretability study (sparse autoencoders) revealed meaningful internal features but also highlighted that the model's decision-making is not yet fully understood

Reach for something else when

You need a lightweight, cost-effective model for high-throughput DNA embedding or scoring on T4 GPUs (use dnabert2, which is much smaller)
You need only DNA embeddings and the model's independent validation track record is critical for your application (use dnabert2, which has years of benchmark validation)
You need codon optimization, restriction site checking, or deterministic DNA feature extraction (use dna_chisel)
You are working exclusively with short regulatory elements (<1 kbp) where Evo2's long-context capability provides no advantage over cheaper models like DNABERT-2
You need protein-level analysis from coding DNA (translate and use esm2 directly)
You need function-conditioned DNA generation with specific functional labels (no built-in conditioning mechanism; consider custom fine-tuning or prompt engineering)
You need RNA-specific analysis — Evo2 accepts only ACGT characters
You need a model with extensive, multi-year real-world deployment experience (use dnabert2)

Alternatives

Model	Better when	Worse when
evo	More mature publication (Science 2024) with experimental validation of generated sequences; simpler model for prokaryotic-focused tasks where eukaryotic coverage is unnecessary	Prokaryotic-only training, no embedding endpoint, shorter context (8 kbp vs up to 1M), and single model size; Evo2 is strictly more capable for multi-domain analysis
dnabert2	Lightweight (117M on T4), BPE tokenization, Apache-2.0 license, and extensive GUE benchmark validation for regulatory element tasks	Much shorter context (~4-8 kbp), no generation, smaller capacity, and masked LM architecture; Evo2 is superior for long-range and generative tasks
omni_dna	BPE tokenization may better capture intermediate-scale motifs; recent autoregressive architecture designed for multi-task flexibility	Smaller model (1B), no generation endpoint, limited validation, and no multi-domain training; Evo2 is more capable across all dimensions

API & schema¶

Variants

Variant	Endpoint slug	GPU	CPU	Memory
1b-base	`evo2-1b-base`	l4	4.0	16 GB

Call an action with POST /api/v1/{slug}/{action} — the request envelope is {"items": [...], "params": {...}} and a success returns {"results": [...]}. See the HTTP API page for the base URL, error shape, and full contract.

`encode`¶

Call it

curl -X POST http://127.0.0.1:8000/api/v1/evo2-1b-base/encode \
  -H "Content-Type: application/json" \
  -d '{
  "items": [
    {
      "sequence": "MKTAYIAKQRQISFVKSHFSRQLEERLGLIE"
    }
  ]
}'

Request — Evo2EncodeRequest

Field	Type	Required	Constraints	Description
`params`	Evo2EncodeRequestParams	no		Optional parameters controlling this action (defaults are used when omitted).
`items`	list[Evo2EncodeRequestItem]	yes	items 1–1	Batch of inputs to process in a single request. Up to 1 sequence per request.

Nested types

Evo2EncodeIncludeOptions

Allowed values: mean, last

Evo2EncodeRequestItem

Field	Type	Required	Constraints	Description
`sequence`	string	yes	len 1–4096	A DNA sequence (A/C/G/T).

Evo2EncodeRequestParams

Field	Type	Required	Constraints	Description
`embedding_layers`	list[integer]	no	default `[-2]`	Transformer layers whose embeddings to extract; supports negative indexing from the last layer.
`mlp_layer`	integer	no	default `3`	Index of the MLP sublayer within each transformer block used for embedding extraction.
`include`	list[Evo2EncodeIncludeOptions]	no	default `['mean']`	Optional outputs to compute and include in the response.

Raw JSON Schema

{
  "$defs": {
    "Evo2EncodeIncludeOptions": {
      "enum": [
        "mean",
        "last"
      ],
      "title": "Evo2EncodeIncludeOptions",
      "type": "string"
    },
    "Evo2EncodeRequestItem": {
      "additionalProperties": false,
      "properties": {
        "sequence": {
          "description": "A DNA sequence (A/C/G/T).",
          "maxLength": 4096,
          "minLength": 1,
          "title": "Sequence",
          "type": "string"
        }
      },
      "required": [
        "sequence"
      ],
      "title": "Evo2EncodeRequestItem",
      "type": "object"
    },
    "Evo2EncodeRequestParams": {
      "additionalProperties": false,
      "properties": {
        "embedding_layers": {
          "description": "Transformer layers whose embeddings to extract; supports negative indexing from the last layer.",
          "items": {
            "type": "integer"
          },
          "title": "Embedding Layers",
          "type": "array",
          "default": [
            -2
          ]
        },
        "mlp_layer": {
          "default": 3,
          "description": "Index of the MLP sublayer within each transformer block used for embedding extraction.",
          "title": "Mlp Layer",
          "type": "integer"
        },
        "include": {
          "description": "Optional outputs to compute and include in the response.",
          "items": {
            "$ref": "#/$defs/Evo2EncodeIncludeOptions"
          },
          "title": "Include",
          "type": "array",
          "default": [
            "mean"
          ]
        }
      },
      "title": "Evo2EncodeRequestParams",
      "type": "object"
    }
  },
  "additionalProperties": false,
  "properties": {
    "params": {
      "$ref": "#/$defs/Evo2EncodeRequestParams",
      "description": "Optional parameters controlling this action (defaults are used when omitted)."
    },
    "items": {
      "description": "Batch of inputs to process in a single request. Up to 1 sequence per request.",
      "items": {
        "$ref": "#/$defs/Evo2EncodeRequestItem"
      },
      "maxItems": 1,
      "minItems": 1,
      "title": "Items",
      "type": "array"
    }
  },
  "required": [
    "items"
  ],
  "title": "Evo2EncodeRequest",
  "type": "object"
}

Response — Evo2EncodeResponse

Field	Type	Required	Constraints	Description
`results`	list[Evo2EncodeResponseResult]	yes		Per-input results, returned in the same order as the request items.

Nested types

Evo2EncodeResponseEmbedding

Field	Type	Required	Description
`layer`	integer	yes	Model layer this representation was taken from.
`mean`	list[number] \| null	no	Mean-pooled embedding vector over all non-padded sequence positions for this layer.
`last`	list[number] \| null	no	Last-token embedding vector for this layer; null if not requested.

Evo2EncodeResponseResult

Field	Type	Required	Constraints	Description
`embeddings`	list[Evo2EncodeResponseEmbedding]	yes		Per-layer embedding vectors for the sequence.

Raw JSON Schema

{
  "$defs": {
    "Evo2EncodeResponseEmbedding": {
      "exclude_none": true,
      "exclude_unset": true,
      "properties": {
        "layer": {
          "description": "Model layer this representation was taken from.",
          "title": "Layer",
          "type": "integer"
        },
        "mean": {
          "anyOf": [
            {
              "items": {
                "type": "number"
              },
              "type": "array"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Mean-pooled embedding vector over all non-padded sequence positions for this layer.",
          "title": "Mean"
        },
        "last": {
          "anyOf": [
            {
              "items": {
                "type": "number"
              },
              "type": "array"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Last-token embedding vector for this layer; null if not requested.",
          "title": "Last"
        }
      },
      "required": [
        "layer"
      ],
      "title": "Evo2EncodeResponseEmbedding",
      "type": "object"
    },
    "Evo2EncodeResponseResult": {
      "properties": {
        "embeddings": {
          "description": "Per-layer embedding vectors for the sequence.",
          "items": {
            "$ref": "#/$defs/Evo2EncodeResponseEmbedding"
          },
          "title": "Embeddings",
          "type": "array"
        }
      },
      "required": [
        "embeddings"
      ],
      "title": "Evo2EncodeResponseResult",
      "type": "object"
    }
  },
  "properties": {
    "results": {
      "description": "Per-input results, returned in the same order as the request items.",
      "items": {
        "$ref": "#/$defs/Evo2EncodeResponseResult"
      },
      "title": "Results",
      "type": "array"
    }
  },
  "required": [
    "results"
  ],
  "title": "Evo2EncodeResponse",
  "type": "object"
}

`log_prob`¶

Call it

curl -X POST http://127.0.0.1:8000/api/v1/evo2-1b-base/log_prob \
  -H "Content-Type: application/json" \
  -d '{
  "items": [
    {
      "sequence": "MKTAYIAKQRQISFVKSHFSRQLEERLGLIE"
    }
  ]
}'

Request — Evo2LogProbRequest

Field	Type	Required	Constraints	Description
`items`	list[Evo2LogProbRequestItem]	yes	items 1–1	Batch of inputs to process in a single request. Up to 1 sequence per request.

Nested types

Evo2LogProbRequestItem

Field	Type	Required	Constraints	Description
`sequence`	string	yes	len 1–4096	A DNA sequence (A/C/G/T).

Raw JSON Schema

{
  "$defs": {
    "Evo2LogProbRequestItem": {
      "additionalProperties": false,
      "properties": {
        "sequence": {
          "description": "A DNA sequence (A/C/G/T).",
          "maxLength": 4096,
          "minLength": 1,
          "title": "Sequence",
          "type": "string"
        }
      },
      "required": [
        "sequence"
      ],
      "title": "Evo2LogProbRequestItem",
      "type": "object"
    }
  },
  "additionalProperties": false,
  "properties": {
    "items": {
      "description": "Batch of inputs to process in a single request. Up to 1 sequence per request.",
      "items": {
        "$ref": "#/$defs/Evo2LogProbRequestItem"
      },
      "maxItems": 1,
      "minItems": 1,
      "title": "Items",
      "type": "array"
    }
  },
  "required": [
    "items"
  ],
  "title": "Evo2LogProbRequest",
  "type": "object"
}

Response — Evo2LogProbResponse

Field	Type	Required	Constraints	Description
`results`	list[Evo2LogProbResponseResult]	yes		Per-input results, returned in the same order as the request items.

Nested types

Evo2LogProbResponseResult

Field	Type	Required	Constraints	Description
`log_prob`	number	yes		Log-likelihood of the sequence under the model.

Raw JSON Schema

{
  "$defs": {
    "Evo2LogProbResponseResult": {
      "properties": {
        "log_prob": {
          "description": "Log-likelihood of the sequence under the model.",
          "title": "Log Prob",
          "type": "number"
        }
      },
      "required": [
        "log_prob"
      ],
      "title": "Evo2LogProbResponseResult",
      "type": "object"
    }
  },
  "properties": {
    "results": {
      "description": "Per-input results, returned in the same order as the request items.",
      "items": {
        "$ref": "#/$defs/Evo2LogProbResponseResult"
      },
      "title": "Results",
      "type": "array"
    }
  },
  "required": [
    "results"
  ],
  "title": "Evo2LogProbResponse",
  "type": "object"
}

`generate`¶

Call it

curl -X POST http://127.0.0.1:8000/api/v1/evo2-1b-base/generate \
  -H "Content-Type: application/json" \
  -d '{
  "items": [
    {
      "prompt": "string"
    }
  ]
}'

Request — Evo2GenerateRequest

Field	Type	Required	Constraints	Description
`params`	Evo2GenerateRequestParams	no		Optional parameters controlling this action (defaults are used when omitted).
`items`	list[Evo2GenerateRequestItem]	yes	items 1–1	Batch of inputs to process in a single request. Up to 1 sequence per request.

Nested types

Evo2GenerateRequestItem

Field	Type	Required	Constraints	Description
`prompt`	string	yes	len 1–4096	DNA seed sequence (A/C/G/T only) from which to continue autoregressive generation.

Evo2GenerateRequestParams

Field	Type	Required	Constraints	Description
`max_new_tokens`	integer	no	≥1; ≤4096; default `100`	Maximum number of new tokens to generate.
`temperature`	number	no	≥0.0; default `1.0`	Sampling temperature; higher values increase diversity.
`top_k`	integer	no	≥1; default `4`	Top-k sampling cutoff; only the k most likely tokens are sampled.
`top_p`	number	no	≥0.0; ≤1.0; default `1.0`	Nucleus (top-p) sampling threshold.
`seed`	integer \| null	no		Random seed for reproducible sampling.

Raw JSON Schema

{
  "$defs": {
    "Evo2GenerateRequestItem": {
      "additionalProperties": false,
      "properties": {
        "prompt": {
          "description": "DNA seed sequence (A/C/G/T only) from which to continue autoregressive generation.",
          "maxLength": 4096,
          "minLength": 1,
          "title": "Prompt",
          "type": "string"
        }
      },
      "required": [
        "prompt"
      ],
      "title": "Evo2GenerateRequestItem",
      "type": "object"
    },
    "Evo2GenerateRequestParams": {
      "additionalProperties": false,
      "properties": {
        "max_new_tokens": {
          "default": 100,
          "description": "Maximum number of new tokens to generate.",
          "maximum": 4096,
          "minimum": 1,
          "title": "Max New Tokens",
          "type": "integer"
        },
        "temperature": {
          "default": 1.0,
          "description": "Sampling temperature; higher values increase diversity.",
          "minimum": 0.0,
          "title": "Temperature",
          "type": "number"
        },
        "top_k": {
          "default": 4,
          "description": "Top-k sampling cutoff; only the k most likely tokens are sampled.",
          "minimum": 1,
          "title": "Top K",
          "type": "integer"
        },
        "top_p": {
          "default": 1.0,
          "description": "Nucleus (top-p) sampling threshold.",
          "maximum": 1.0,
          "minimum": 0.0,
          "title": "Top P",
          "type": "number"
        },
        "seed": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Random seed for reproducible sampling.",
          "title": "Seed"
        }
      },
      "title": "Evo2GenerateRequestParams",
      "type": "object"
    }
  },
  "additionalProperties": false,
  "properties": {
    "params": {
      "$ref": "#/$defs/Evo2GenerateRequestParams",
      "description": "Optional parameters controlling this action (defaults are used when omitted)."
    },
    "items": {
      "description": "Batch of inputs to process in a single request. Up to 1 sequence per request.",
      "items": {
        "$ref": "#/$defs/Evo2GenerateRequestItem"
      },
      "maxItems": 1,
      "minItems": 1,
      "title": "Items",
      "type": "array"
    }
  },
  "required": [
    "items"
  ],
  "title": "Evo2GenerateRequest",
  "type": "object"
}

Response — Evo2GenerateResponse

Field	Type	Required	Constraints	Description
`results`	list[Evo2GenerateResponseResult]	yes		Per-input results, returned in the same order as the request items.

Nested types

Evo2GenerateResponseResult

Field	Type	Required	Constraints	Description
`generated`	string	yes		Autoregressive continuation of the input prompt as a DNA sequence (A/C/G/T).

Raw JSON Schema

{
  "$defs": {
    "Evo2GenerateResponseResult": {
      "properties": {
        "generated": {
          "description": "Autoregressive continuation of the input prompt as a DNA sequence (A/C/G/T).",
          "title": "Generated",
          "type": "string"
        }
      },
      "required": [
        "generated"
      ],
      "title": "Evo2GenerateResponseResult",
      "type": "object"
    }
  },
  "properties": {
    "results": {
      "description": "Per-input results, returned in the same order as the request items.",
      "items": {
        "$ref": "#/$defs/Evo2GenerateResponseResult"
      },
      "title": "Results",
      "type": "array"
    }
  },
  "required": [
    "results"
  ],
  "title": "Evo2GenerateResponse",
  "type": "object"
}

Usage¶

One-line summary: A multi-domain autoregressive DNA foundation model (1B--40B parameters) built on StripedHyena, supporting embedding extraction, log-probability scoring, and sequence generation across prokaryotic, eukaryotic, and viral genomes.

Overview¶

Evo 2 is the successor to Evo 1, developed by the Arc Institute, Stanford, and collaborators. It extends the StripedHyena hybrid architecture to larger scales (up to 40B parameters) and, critically, is trained on genomes from all domains of life -- prokaryotes, eukaryotes, and viruses -- overcoming Evo 1's prokaryotic bias.

Evo 2 offers three actions: embedding extraction (new in Evo 2), log-probability scoring, and sequence generation. This makes it a versatile DNA foundation model suitable for both analysis (embeddings, scoring) and design (generation) workflows.

The model was described in Brixi et al. "Genome modeling and design across all domains of life with Evo 2" (bioRxiv, 2025).

Architecture¶

Property	Value
Architecture	StripedHyena (hybrid gated convolution + attention)
Tokenization	Byte-level (single nucleotide per token)
Vocabulary	A, C, G, T + special tokens
Training data	Multi-domain genomes (prokaryotic, eukaryotic, viral)
Training objective	Autoregressive next-token prediction
Max sequence length	4,096 nt (BioLM API)
License	Apache-2.0

For detailed architecture information, see MODEL.md.

Capabilities & Limitations¶

CAN be used for: - Extracting per-layer DNA embeddings (mean or last-token pooling) for downstream ML tasks - Scoring DNA sequences via total log-probability under the autoregressive distribution - Generating novel DNA sequences from a seed prompt with configurable sampling parameters - Zero-shot variant effect assessment by comparing wild-type vs. mutant log-probabilities - Multi-domain genomic analysis (prokaryotic, eukaryotic, viral)

CANNOT be used for: - Sequences containing ambiguous bases (N, R, Y, etc.) -- only A, C, G, T accepted - Sequences longer than 4,096 nucleotides (BioLM API limit) - RNA sequences (U is not accepted) - Protein sequences (use ESM2 or similar)

Other considerations: - The generate action is stochastic by default; provide an explicit seed for reproducibility - Log-probability scores are summed over all positions; normalize by length for cross-length comparisons - Batch size is limited to 1 item per request

Usage Examples¶

# Encode -- extract embeddings
from models.evo2.schema import (
    Evo2EncodeIncludeOptions,
    Evo2EncodeRequest,
    Evo2EncodeRequestItem,
    Evo2EncodeRequestParams,
)

encode_request = Evo2EncodeRequest(
    params=Evo2EncodeRequestParams(
        embedding_layers=[-2],
        include=[Evo2EncodeIncludeOptions.MEAN, Evo2EncodeIncludeOptions.LAST],
    ),
    items=[Evo2EncodeRequestItem(sequence="ACGTACGTACGTACGT")],
)

# Score DNA sequences
from models.evo2.schema import Evo2LogProbRequest, Evo2LogProbRequestItem

logprob_request = Evo2LogProbRequest(
    items=[Evo2LogProbRequestItem(sequence="ATGATGATGATGATG")]
)

# Generate DNA sequences with seed for reproducibility
from models.evo2.schema import (
    Evo2GenerateRequest,
    Evo2GenerateRequestItem,
    Evo2GenerateRequestParams,
)

generate_request = Evo2GenerateRequest(
    params=Evo2GenerateRequestParams(
        max_new_tokens=100,
        temperature=0.8,
        top_k=10,
        seed=42,
    ),
    items=[Evo2GenerateRequestItem(prompt="ATGAAAGCAATTTTCGTACTG")],
)

Architecture & training¶

Architecture¶

Model Type & Innovation¶

Evo 2 is a large-scale autoregressive DNA foundation model developed by the Arc Institute, Stanford, and collaborators. It is the successor to Evo 1 and represents a major scaling advance in genomic language modeling. Evo 2 extends the StripedHyena hybrid architecture -- combining gated convolutions (Hyena operators) with multi-head attention -- to model sizes of 1B, 7B, and 40B parameters.

The key innovations of Evo 2 over its predecessor include: - Massive scaling: From 7B (Evo 1) to 40B parameters, demonstrating continued scaling benefits for genomic modeling - Multi-domain training: Trained on genomes from all domains of life (prokaryotes, eukaryotes, and viruses), unlike Evo 1 which focused on prokaryotic genomes - Embedding extraction: Unlike Evo 1, Evo 2 exposes per-layer embedding extraction via the encode action, enabling use as a feature extractor for downstream tasks - Three-action API: Supports embedding extraction, log-probability scoring, and sequence generation in a single model

Parameters & Layers¶

Variant	Parameters	Context	Architecture	GPU
evo2-1b-base	~1B	8k nt	StripedHyena	L4
evo2-7b-base	~7B	8k nt	StripedHyena	L4

Additional variants defined but not currently deployed: evo2-7b (1M context), evo2-40b-base (8k), evo2-40b (1M context).

Common across all variants:

Property	Value
Architecture	StripedHyena (hybrid gated convolution + attention)
Tokenization	Byte-level (single nucleotide per token)
Vocabulary	A, C, G, T + special tokens
Positional encoding	Implicit via convolutional filters + RoPE in attention layers

Training Data¶

Property	Details
Dataset	Multi-domain genomic sequences
Composition	Prokaryotic, eukaryotic, and viral genomes
Preprocessing	Byte-level tokenization; single nucleotide per token

Loss Function & Objective¶

Standard autoregressive (next-token prediction) objective:

L = -sum_{t=1}^{T} log P(x_t | x_{<t})

This yields both generative capability (sampling new sequences) and scoring capability (evaluating log-probability of existing sequences).

Tokenization / Input Processing¶

Property	Details
Tokenizer	Byte-level (character-level), single nucleotide tokens
Special tokens	BOS, PAD
Max sequence length	4,096 nt (BioLM API limit)
Input validation	A, C, G, T only (unambiguous DNA)
Batch size	1 sequence per request

Performance & Benchmarks¶

Published Benchmarks¶

From Brixi et al. "Genome modeling and design across all domains of life with Evo 2" (bioRxiv, 2025):

Key reported findings: - Evo 2 outperforms Evo 1 on DNA fitness prediction benchmarks - Multi-domain training improves generalization to eukaryotic sequences - Scaling from 1B to 40B parameters yields consistent improvements

BioLM Verification Results¶

Action	Test Input	Tolerance	Status
`encode`	"ACGTACGTAC", layer 22	rel_tol=1e-4	PASS
`log_prob`	"ACGTACGTAC"	rel_tol=1e-4	PASS
`generate`	Prompt "ACGT", 10 tokens	Valid DNA output	PASS

Comparison to Alternatives¶

Model	Key Advantage	Key Disadvantage
Evo2 (this)	Multi-domain training; embeddings + generation + scoring	Larger compute footprint than Evo 1
Evo 1	Proven in Science 2024; lighter weight	Prokaryotic bias; no embedding endpoint
Nucleotide Transformer	6-mer tokenization captures broader context per token	No generation; encoder-only
DNABERT-2	Lightweight (117M); BPE tokenization	Short context; no generation

Error Bars & Confidence¶

encode and log_prob are deterministic for the same input and hardware
generate is stochastic by default; provide explicit seed for reproducibility
Small floating-point differences (within 1e-4) may occur across different GPU architectures

Strengths & Limitations¶

Pros¶

Multi-domain training covers prokaryotic, eukaryotic, and viral genomes
Three complementary actions: embedding extraction, scoring, and generation
Byte-level tokenization preserves single-nucleotide resolution
StripedHyena architecture enables near-linear scaling with sequence length
Multiple model sizes (1B, 7B) allow speed/quality tradeoffs

Cons¶

Large model footprint -- 7B variant requires significant GPU resources
Max API sequence length of 4,096 nt limits some genomic applications
Stochastic generation requires explicit seed management for reproducibility
Newer model with less downstream validation than Evo 1

Known Failure Modes¶

Very short sequences (< 10 nt): Insufficient context for meaningful embeddings or log-probabilities
Repetitive sequences: Highly repetitive DNA (microsatellites, tandem repeats) may receive unreliable scores
Non-DNA input: Only A, C, G, T accepted; ambiguity codes and RNA are rejected

Implementation Details¶

Inference Pipeline¶

Request
  |-- 1. Validate input (DNA bases only, length <= 4096)
  |-- 2. Route to action:
  |
  |-- [encode]
  |     |-- Tokenize sequences
  |     |-- Pad batch to max length
  |     |-- Forward pass with return_embeddings=True
  |     |-- Extract requested layers (blocks.N.mlp.l3)
  |     |-- Compute mean/last pooling over non-padded tokens
  |     |-- Return per-layer embeddings
  |
  |-- [log_prob]
  |     |-- Tokenize sequences
  |     |-- model.score_sequences(reduce_method="sum")
  |     |-- Return total log-prob per sequence
  |
  |-- [generate]
        |-- Set random seeds (user-provided or time-based)
        |-- model.generate(cached_generation=True)
        |-- Return generated sequence

Memory & Compute Profile¶

Variant	GPU	Memory	CPU
evo2-1b-base	L4	16 GB	4 cores

Only evo2-1b-base is currently enabled and tested. Larger variants (7b-base and up) are planned; see README.md for the full variant list. Their resource requirements will be higher and are not yet finalized.

Determinism & Reproducibility¶

Action	Deterministic	Notes
`encode`	Yes	Pure forward pass, no randomness
`log_prob`	Yes	Uses score_sequences with sum reduction
`generate`	With seed	Time-based entropy when seed=None; reproducible with explicit seed

When a seed is provided for generate: - random.seed(seed), np.random.seed(seed), torch.manual_seed(seed), torch.cuda.manual_seed_all(seed)

Caching Behavior¶

Response caching is handled outside the model container, by the gateway layer: - Cache key derived from full request payload including parameters - For generate with no seed, cache misses are expected on repeated calls

Versions & Changelog¶

Version	Date	Changes
v1	--	Initial implementation with encode, log_prob, and generate actions; 1b-base variant enabled (7b-base and larger planned)

Biology¶

Molecule Coverage¶

Primary Molecule Type(s)¶

Evo 2 is trained on genomic DNA from all domains of life -- prokaryotes (bacteria and archaea), eukaryotes (including human and other multicellular organisms), and viruses. This is a major expansion over Evo 1, which was limited to prokaryotic and phage genomes.

The model handles: - Prokaryotic genomes: Bacterial and archaeal chromosomes, plasmids, and operons -- the strongest domain due to training data composition - Eukaryotic genomes: Coding and non-coding regions from diverse eukaryotes, including human - Viral genomes: Bacteriophage and eukaryotic virus sequences - Coding regions: Genes, exons, open reading frames across all domains - Non-coding regions: Intergenic sequences, regulatory elements, introns

Performance considerations: - Multi-domain training improves eukaryotic sequence modeling compared to Evo 1 - The model accepts only unambiguous DNA bases (A, C, G, T) - Single-nucleotide (byte-level) tokenization preserves full sequence resolution

Cross-Applicability¶

Molecule / Domain	Applicability	Evidence	Caveats
Prokaryotic genomes	High	Strong training domain; successor to Evo 1	Best performance expected
Eukaryotic coding regions	Moderate-High	Multi-domain training includes eukaryotes	Less training emphasis than prokaryotes
Eukaryotic regulatory elements	Moderate	Trained on eukaryotic genomes including enhancers	Complex distal regulation may be poorly captured
Viral genomes	High	Included in training data	Diverse viral architectures well-represented
Synthetic DNA	Moderate	Can score constructs via log-probability	Novel synthetic motifs may be out-of-distribution
RNA sequences	Not supported	Input validation rejects non-ACGT characters	Convert U to T or use RNA-specific models
Protein sequences	Not applicable	DNA-only model	Use ESM2, SaProt, or similar protein LMs

Biological Problems Addressed¶

Problem 1: DNA Embedding Extraction¶

Why this matters: Many downstream genomic analyses require fixed-dimensional numerical representations of variable-length DNA sequences. Unlike Evo 1, Evo 2 provides per-layer embedding extraction, enabling use as a feature backbone for supervised learning tasks -- gene classification, regulatory element prediction, variant effect scoring, and more.

How Evo 2 addresses it: The encode action computes embeddings from specified transformer layers. Users can request mean-pooled or last-token embeddings, and can specify which internal layers to extract from (supporting negative indexing). This flexibility allows researchers to experiment with different representation depths.

Biological meaning: Embeddings from earlier layers tend to capture local sequence patterns (dinucleotide composition, codon usage), while deeper layers capture more abstract, long-range dependencies (gene structure, regulatory context).

Problem 2: DNA Sequence Fitness Scoring¶

Why this matters: Evaluating whether a DNA sequence is evolutionarily plausible or functionally constrained is fundamental to variant effect prediction, synthetic sequence evaluation, and gene essentiality analysis.

How Evo 2 addresses it: The log_prob action computes the total log-probability of a DNA sequence under the autoregressive distribution. Higher (less negative) scores indicate sequences more consistent with the training distribution.

Interpreting scores: - More negative values = less likely sequences under the model - Relative comparisons (wild-type vs. mutant) are more informative than absolute values - Scores are summed over positions; normalize by length for cross-length comparisons

Problem 3: DNA Sequence Generation¶

Why this matters: Synthetic biology requires generating novel DNA sequences that are biologically plausible -- realistic codon usage, proper gene structure, and functional regulatory elements. Evo 2's multi-domain training makes it suitable for generating sequences across all domains of life, not just prokaryotes.

How Evo 2 addresses it: The generate action produces new DNA by autoregressively sampling from the learned distribution, given a seed prompt. Parameters (temperature, top-k, top-p) control the diversity-quality tradeoff. Generated sequences should be validated computationally and experimentally before use.

Applied Use Cases¶

Use Case 1: Multi-Domain Genome Modeling (Published)¶

Source: Brixi et al. "Genome modeling and design across all domains of life with Evo 2." bioRxiv (2025). doi:10.1101/2025.02.18.638918

Evo 2 demonstrates improved genome modeling across prokaryotic, eukaryotic, and viral domains compared to Evo 1, establishing the benefit of multi-domain training for genomic foundation models.

Use Case 2: Eukaryotic Variant Effect Prediction (Anticipated)¶

Using Evo 2 embeddings or log-probability scores to predict the functional impact of mutations in human and other eukaryotic genomes -- a task where Evo 1's prokaryotic bias was a limitation.

Predecessor Models¶

Evo 1 (Nguyen et al., Science 2024): The original 7B DNA model trained on prokaryotic genomes. Evo 2 extends this with multi-domain training and additional model sizes. Evo 1 is available separately in this catalog.

Complementary Models¶

Nucleotide Transformer: BERT-style DNA embeddings. Use NT for masked language modeling tasks; use Evo 2 for generation and autoregressive scoring.
ESM2: Protein language model. For DNA-to-protein workflows, use Evo 2 for DNA analysis and ESM2 for downstream protein analysis.
DNA-Chisel: Deterministic DNA feature extraction. Combine with Evo 2 embeddings for interpretable feature engineering.

Alternative Models¶

Alternative	Advantage over Evo 2	Disadvantage vs Evo 2
Evo 1	Published in Science; well-validated	Prokaryotic only; no embedding endpoint
Nucleotide Transformer	6-mer tokenization; good for classification	No generation; encoder-only
DNABERT-2	Lightweight; BPE tokenization	Shorter context; no generation
HyenaDNA	Very long context (up to 1M bp)	Smaller model; less training data

Biological Background¶

DNA (deoxyribonucleic acid) is the molecule encoding genetic information in all cellular life. It consists of four nucleotide bases -- adenine (A), cytosine (C), guanine (G), and thymine (T) -- arranged in a double-helical structure. The sequence of these bases encodes genes (transcribed to RNA, often translated to protein) and regulatory instructions controlling gene expression.

Key concepts relevant to Evo 2:

Autoregressive modeling: Predicting the next nucleotide given all preceding nucleotides. This objective naturally captures the statistical structure of genomes -- codon usage, regulatory motifs, gene boundaries -- without explicit supervision.
Multi-domain training: By training on genomes from bacteria, archaea, eukaryotes, and viruses, Evo 2 learns universal patterns of DNA organization that transcend individual species, while also capturing domain-specific features.
Embeddings: Dense numerical vectors representing DNA sequences in a learned high-dimensional space. Similar sequences (by function, structure, or evolutionary origin) cluster together in embedding space.
Log-probability scoring: The total log-probability of a sequence under the model serves as a proxy for evolutionary plausibility. Functionally constrained regions (essential genes, conserved regulatory elements) tend to have higher log-probabilities.
StripedHyena: A hybrid architecture that combines efficient gated convolutions (for capturing long-range patterns without quadratic cost) with attention layers (for precise positional interactions), enabling modeling of long genomic sequences.

Sources & license¶

License: Apache-2.0 (text)

Papers

Genome modeling and design across all domains of life with Evo 2 — bioRxiv, 2025 · DOI

Source repositories

github: https://github.com/ArcInstitute/evo2
huggingface: https://huggingface.co/arcinstitute/evo2_1b_base

Cite

@article{brixi2025evo2,
  title={Genome modeling and design across all domains of life with Evo 2},
  author={Brixi, Garyk and Durber, Matthew G and Nguyen, Eric and Poli, Michael and Bartie, Liam J and Hie, Brian L and Re, Christopher and Hsu, Patrick D},
  journal={bioRxiv},
  year={2025},
  doi={10.1101/2025.02.18.638918}
}

Evo2¶

At a glance¶

API & schema¶

encode¶

log_prob¶

generate¶

Usage¶

Overview¶

Architecture¶

Capabilities & Limitations¶

Usage Examples¶

Architecture & training¶

Architecture¶

Model Type & Innovation¶

Parameters & Layers¶

Training Data¶

Loss Function & Objective¶

Tokenization / Input Processing¶

Performance & Benchmarks¶

Published Benchmarks¶

BioLM Verification Results¶

Comparison to Alternatives¶

Error Bars & Confidence¶

Strengths & Limitations¶

Pros¶

Cons¶

Known Failure Modes¶

Implementation Details¶

Inference Pipeline¶

Memory & Compute Profile¶

Determinism & Reproducibility¶

Caching Behavior¶

Versions & Changelog¶

Biology¶

Molecule Coverage¶

Primary Molecule Type(s)¶

Cross-Applicability¶

Biological Problems Addressed¶

Problem 1: DNA Embedding Extraction¶

Problem 2: DNA Sequence Fitness Scoring¶

Problem 3: DNA Sequence Generation¶

Applied Use Cases¶

Use Case 1: Multi-Domain Genome Modeling (Published)¶

Use Case 2: Eukaryotic Variant Effect Prediction (Anticipated)¶

Related Models¶

Predecessor Models¶

Complementary Models¶

Alternative Models¶

Biological Background¶

Sources & license¶

`encode`¶

`log_prob`¶

`generate`¶