Evo¶

A 7B-parameter autoregressive DNA language model built on the StripedHyena architecture, capable of genome-scale sequence generation and log-probability scoring at single-nucleotide resolution.

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

Actions: log_prob, generate · Variants: 1

At a glance¶

Use it when

You need to generate novel prokaryotic DNA sequences — genes, operons, regulatory elements, or synthetic genome fragments — from a seed prompt
You need autoregressive log-probability scoring for prokaryotic DNA variant effect prediction where directional context matters
You are designing synthetic microbial genomes and need a generative model trained on diverse prokaryotic genomic data
You are working with bacteriophage sequences and need a model with strong phage genomic coverage
You need DNA sequence generation at the gene-to-operon scale (up to 8 kbp) for synthetic biology applications in prokaryotic hosts
You want a well-published, experimentally validated generative DNA model with a strong publication track record (Science 2024)

Strengths

Autoregressive generation capability enables de novo DNA sequence design — the only model in this catalog (alongside Evo2) that can generate novel DNA sequences from a seed prompt
Published in Science (2024) with experimental validation of generated sequences, including functional CRISPR-Cas system designs and synthetic genome generation with plausible gene structures
7B-parameter StripedHyena architecture provides single-nucleotide (byte-level) resolution without tokenization artifacts, preserving full sequence fidelity for variant effect analysis
Up to 4 kbp per request (8k native context window) covers most prokaryotic genes, operons, and regulatory regions in a single inference pass
True autoregressive log-probability scoring captures directional sequence dependencies that masked models (DNABERT-2, NT) cannot represent
Specialized fine-tuned variants exist for CRISPR and transposon design (not included in this catalog), demonstrating domain-specific adaptation potential
Apache-2.0 license permits unrestricted commercial and academic use
Strong coverage of prokaryotic genomic diversity from training on the OpenGenome dataset of bacterial, archaeal, and phage genomes

Limitations

Prokaryotic training bias — the OpenGenome dataset consists primarily of bacterial, archaeal, and phage sequences; eukaryotic features (complex splicing, distal enhancers, large introns) are poorly modeled
No embedding extraction endpoint — cannot produce dense vector representations for downstream ML tasks; use DNABERT-2, OmniDNA, or Evo2 instead for embeddings
8 kbp context is insufficient for eukaryotic gene loci, long-range regulatory interactions, or genome-scale analysis (Evo2 extends this to 1M tokens)
7B parameters require an L4 GPU, making it substantially more expensive than DNABERT-2 (T4) for scoring-only tasks
Generated sequences require extensive computational and experimental validation — the model provides no guarantee of function, only statistical plausibility
No built-in conditioning mechanism for specific functions (e.g., EC numbers, gene categories); generation is prompt-conditioned only
Superseded by Evo2 in terms of training data breadth (multi-domain vs prokaryotic-only) and context length (1M vs 8K tokens)

Reach for something else when

You need to analyze eukaryotic genomic features such as complex splicing signals, distal enhancer-promoter interactions, or large introns (use evo2, which includes eukaryotic training data)
You need DNA embeddings for downstream ML tasks (use dnabert2, omni_dna, or evo2 — Evo has no embedding endpoint)
You need genome-scale context windows exceeding 8 kbp (use evo2, which supports up to 1M tokens)
You need a lightweight model for high-throughput DNA scoring on T4 GPUs (use dnabert2 or omni_dna, which are smaller and cheaper)
You need codon optimization or deterministic sequence analysis features (use dna_chisel)
You need protein-level sequence analysis (translate coding regions and use esm2)
You need multi-domain DNA modeling covering both prokaryotes and eukaryotes (use evo2 instead)
You need function-conditioned generation (e.g., specifying enzyme class or gene function) rather than prompt-conditioned generation

Alternatives

Model	Better when	Worse when
evo2	Multi-domain training (prokaryotes + eukaryotes + viruses), up to 1M-token context, embedding extraction endpoint, and multiple size variants (1B, 7B)	Evo has a stronger publication record (Science 2024) and is a more mature model; Evo2 is newer and less independently validated
dnabert2	Lightweight (117M on T4), BPE tokenization for fine-grained regulatory element classification, and well-validated on the GUE benchmark	No generation capability, shorter context (~4-8 kbp), and masked LM architecture provides only pseudo-log-likelihood rather than true autoregressive scoring
omni_dna	BPE-tokenized with embedding extraction, 1B-parameter autoregressive architecture for scoring and embedding tasks	No generation capability; Evo is the established choice for DNA sequence design with experimental validation

API & schema¶

Variants

Variant	Endpoint slug	GPU	CPU	Memory
v1.5-8k	`evo-v1.5-8k`	l4	4.0	8 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.

`log_prob`¶

Call it

curl -X POST http://127.0.0.1:8000/api/v1/evo-v1.5-8k/log_prob \
  -H "Content-Type: application/json" \
  -d '{
  "items": [
    {
      "sequence": "MKTAYIAKQRQISFVKSHFSRQLEERLGLIE"
    }
  ]
}'

Request — EvoLogProbRequest

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

Nested types

EvoLogProbRequestItem

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

Raw JSON Schema

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

Response — EvoLogProbResponse

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

Nested types

EvoLogProbResponseResult

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

Raw JSON Schema

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

`generate`¶

Call it

curl -X POST http://127.0.0.1:8000/api/v1/evo-v1.5-8k/generate \
  -H "Content-Type: application/json" \
  -d '{
  "items": [
    {
      "prompt": "string"
    }
  ]
}'

Request — EvoGenerateRequest

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

Nested types

EvoGenerateRequestItem

Field	Type	Required	Constraints	Description
`prompt`	string	yes	len 1–4096	Seed DNA sequence (A/C/G/T) from which generation continues autoregressively.

EvoGenerateRequestParams

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 `0.0`	Sampling temperature; higher values increase diversity.
`top_k`	integer	no	≥1; default `1`	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.
`prepend_bos`	boolean	no	default `False`	Whether to prepend a BOS token before the prompt during generation.
`seed`	integer \| null	no		Random seed for reproducible sampling.

Raw JSON Schema

{
  "$defs": {
    "EvoGenerateRequestItem": {
      "additionalProperties": false,
      "properties": {
        "prompt": {
          "description": "Seed DNA sequence (A/C/G/T) from which generation continues autoregressively.",
          "maxLength": 4096,
          "minLength": 1,
          "title": "Prompt",
          "type": "string"
        }
      },
      "required": [
        "prompt"
      ],
      "title": "EvoGenerateRequestItem",
      "type": "object"
    },
    "EvoGenerateRequestParams": {
      "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": 0.0,
          "description": "Sampling temperature; higher values increase diversity.",
          "minimum": 0.0,
          "title": "Temperature",
          "type": "number"
        },
        "top_k": {
          "default": 1,
          "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"
        },
        "prepend_bos": {
          "default": false,
          "description": "Whether to prepend a BOS token before the prompt during generation.",
          "title": "Prepend Bos",
          "type": "boolean"
        },
        "seed": {
          "anyOf": [
            {
              "type": "integer"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Random seed for reproducible sampling.",
          "title": "Seed"
        }
      },
      "title": "EvoGenerateRequestParams",
      "type": "object"
    }
  },
  "additionalProperties": false,
  "properties": {
    "params": {
      "$ref": "#/$defs/EvoGenerateRequestParams",
      "description": "Optional parameters controlling this action (defaults are used when omitted)."
    },
    "items": {
      "description": "Batch of inputs to process in a single request. Up to 2 sequences per request.",
      "items": {
        "$ref": "#/$defs/EvoGenerateRequestItem"
      },
      "maxItems": 2,
      "minItems": 1,
      "title": "Items",
      "type": "array"
    }
  },
  "required": [
    "items"
  ],
  "title": "EvoGenerateRequest",
  "type": "object"
}

Response — EvoGenerateResponse

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

Nested types

EvoGenerateResponseResult

Field	Type	Required	Constraints	Description
`generated`	string	yes		Newly generated DNA continuation (does NOT include the prompt), in A/C/G/T.
`score`	number	yes		Average log-probability per token of the generated sequence, reflecting model confidence.

Raw JSON Schema

{
  "$defs": {
    "EvoGenerateResponseResult": {
      "properties": {
        "generated": {
          "description": "Newly generated DNA continuation (does NOT include the prompt), in A/C/G/T.",
          "title": "Generated",
          "type": "string"
        },
        "score": {
          "description": "Average log-probability per token of the generated sequence, reflecting model confidence.",
          "title": "Score",
          "type": "number"
        }
      },
      "required": [
        "generated",
        "score"
      ],
      "title": "EvoGenerateResponseResult",
      "type": "object"
    }
  },
  "properties": {
    "results": {
      "description": "Per-input results, returned in the same order as the request items.",
      "items": {
        "$ref": "#/$defs/EvoGenerateResponseResult"
      },
      "title": "Results",
      "type": "array"
    }
  },
  "required": [
    "results"
  ],
  "title": "EvoGenerateResponse",
  "type": "object"
}

Usage¶

One-line summary: A 7B-parameter autoregressive DNA language model built on the StripedHyena architecture, capable of genome-scale sequence generation and log-probability scoring at single-nucleotide resolution.

Overview¶

Evo is a DNA foundation model developed by the Arc Institute, Stanford, and Together AI. At 7 billion parameters, it is one of the largest language models trained specifically on DNA sequences. Evo uses the StripedHyena architecture -- a hybrid of gated convolutions (Hyena operators) and multi-head attention -- which achieves near-linear scaling with sequence length. This enables Evo to handle context lengths up to 131,072 nucleotides, far beyond what standard Transformers can process efficiently.

Evo is trained on the OpenGenome dataset, a large corpus of prokaryotic and phage genome sequences, using a standard autoregressive (next-token prediction) objective. This dual-purpose training yields both generative capability (producing novel DNA sequences) and scoring capability (evaluating how natural a given DNA sequence is under the model's learned distribution).

The model was published in Science (2024) and represents one of the first demonstrations of genome-scale DNA generation where the produced sequences encode proteins with plausible predicted structures.

Architecture¶

Property	Value
Architecture	StripedHyena (hybrid gated convolution + attention)
Parameters	~7 billion
Tokenization	Byte-level (single nucleotide per token)
Vocabulary	A, C, G, T + special tokens
Training data	OpenGenome (~300B tokens, prokaryotic + phage genomes)
Training objective	Autoregressive next-token prediction
Max sequence length	4,096 nt (BioLM API); 8,192 nt (model native, 8k variant)

For detailed architecture information, see MODEL.md.

Capabilities & Limitations¶

CAN be used for: - Generating novel DNA sequences from a seed prompt (autoregressive sampling with temperature, top-k, top-p control) - Scoring DNA sequences via total log-probability under the autoregressive distribution - Zero-shot variant effect assessment by comparing log-probabilities of wild-type vs. mutant sequences - Evaluating how "natural-like" a synthetic DNA construct is - Prokaryotic genome analysis, including coding regions, regulatory elements, and intergenic sequences

CANNOT be used for: - Sequences containing ambiguous bases (N, R, Y, W, S, etc.) -- only A, C, G, T accepted - Sequences longer than 4,096 nucleotides (BioLM API limit) - RNA sequences (U is not accepted; use RNA-specific models) - Protein sequences (Evo operates on DNA only; use ESM2 or similar) - Per-token embedding extraction (no encode endpoint is exposed) - Eukaryotic-specific tasks (complex splicing, distal enhancer-promoter interactions) -- training data is primarily prokaryotic

Other considerations: - The generate action is stochastic by default. Provide an explicit seed parameter for reproducible outputs. - Log-probability scores are summed over all positions, so longer sequences naturally have more negative total scores. Normalize by length for fair cross-length comparisons. - Batch size is limited to 2 items per request.

Usage Examples¶

Score DNA sequences¶

from models.evo.schema import (
    EvoLogProbRequest,
    EvoLogProbRequestItem,
)

request = EvoLogProbRequest(
    items=[
        EvoLogProbRequestItem(sequence="ACGTACGTACGTACGT"),
        EvoLogProbRequestItem(sequence="ATGATGATGATGATG"),
    ]
)

Generate DNA sequences¶

from models.evo.schema import (
    EvoGenerateRequest,
    EvoGenerateRequestItem,
    EvoGenerateRequestParams,
)

# Greedy generation (deterministic)
request = EvoGenerateRequest(
    params=EvoGenerateRequestParams(
        max_new_tokens=200,
        temperature=0.0,
        top_k=1,
    ),
    items=[
        EvoGenerateRequestItem(prompt="ATGAAAGCAATTTTCGTACTG"),
    ],
)

# Diverse generation with seed for reproducibility
request = EvoGenerateRequest(
    params=EvoGenerateRequestParams(
        max_new_tokens=500,
        temperature=0.7,
        top_k=50,
        top_p=0.95,
        seed=42,
    ),
    items=[
        EvoGenerateRequestItem(prompt="ATGAAAGCAATTTTCGTACTG"),
    ],
)

Architecture & training¶

Architecture¶

Model Type & Innovation¶

Evo is a 7-billion parameter autoregressive language model for DNA sequences. Unlike the majority of biological sequence models that use the Transformer architecture, Evo is built on StripedHyena -- a hybrid architecture combining gated convolutions with multi-head attention. This is a key architectural innovation: StripedHyena replaces the standard quadratic self-attention mechanism with a combination of hyena operators (long convolutions parameterized implicitly) and a reduced number of attention layers. The result is near-linear scaling with sequence length, enabling Evo to process contexts up to 131,072 nucleotides -- far beyond what standard Transformers can handle efficiently.

The StripedHyena architecture interleaves: - Hyena layers: Use implicitly parameterized long convolutions for efficient sequence mixing with sub-quadratic complexity. - Attention layers: Standard multi-head attention inserted periodically (every few layers) to preserve the model's ability to capture precise long-range dependencies.

This hybrid design allows Evo to operate at byte-level tokenization (single nucleotide resolution) without the prohibitive cost that would come from running full attention over sequences of 100k+ tokens.

Parameters & Layers¶

Component	Details
Architecture	StripedHyena (hybrid gated convolution + attention)
Total parameters	~7 billion
Tokenization	Byte-level (character-level), single nucleotide tokens
Vocabulary	DNA bases: A, C, G, T (plus special tokens)
Context lengths	8,192 (8k variants) or 131,072 (131k variant)
Positional encoding	Implicit via convolutional filters (Hyena layers); RoPE in attention layers

Training Data¶

Property	Details
Dataset	OpenGenome
Composition	Prokaryotic and phage genomes spanning diverse taxonomic groups
Sequence type	Whole-genome DNA sequences
Scale	~300 billion tokens of DNA sequence data
Preprocessing	Byte-level tokenization; no k-mer encoding or BPE

The OpenGenome dataset was curated to provide broad coverage of microbial genomic diversity. Evo 1.5 was trained on approximately 50% more data than the original Evo 1 release, improving general DNA modeling capability.

Known biases: - Training data is heavily weighted toward prokaryotic genomes. Performance on eukaryotic sequences (especially large mammalian genomes) may be lower. - Viral and phage genomes are included but represent a smaller fraction of the training distribution. - No explicit inclusion of synthetic sequences or engineered constructs.

Loss Function & Objective¶

Evo is trained with a standard autoregressive (next-token prediction) objective:

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

At each position, the model predicts the probability distribution over the next nucleotide given all preceding nucleotides. This objective naturally yields both: - Generative capability: Sample new sequences by iteratively predicting the next token. - Scoring capability: Evaluate the log-probability of an existing sequence under the learned distribution.

Tokenization / Input Processing¶

Evo uses byte-level (character-level) tokenization, where each DNA nucleotide (A, C, G, T) is a single token. This is distinct from k-mer or BPE tokenization used by some other genomic models.

Token vocabulary: A, C, G, T, plus special tokens (BOS)
No subword encoding: Each nucleotide maps to exactly one token
Maximum sequence length: 4,096 nucleotides (BioLM API cap; the underlying model supports 8,192 for the 8k variant)
Input validation: Only unambiguous DNA bases (A, C, G, T) are accepted; ambiguity codes (N, R, Y, etc.) are rejected

The byte-level approach preserves single-nucleotide resolution, which is essential for tasks like scoring point mutations or generating sequences where every base matters.

Performance & Benchmarks¶

Published Benchmarks¶

From the primary paper (Nguyen et al., Science 2024):

Zero-Shot Fitness Prediction¶

Evo was evaluated on zero-shot prediction of variant fitness across multiple experimental datasets, using per-sequence log-probabilities as the fitness proxy.

Benchmark	Metric	Evo Performance	Notes
Prokaryotic DMS datasets	Spearman rho	Competitive with protein LMs	DNA-level scoring without protein translation
ProteinGym (prokaryotic subset)	Spearman rho	Comparable to ESM-1v on relevant targets	First DNA model evaluated on protein fitness

Gene Essentiality Prediction¶

Evo's log-probabilities correlate with gene essentiality in prokaryotic genomes, demonstrating that the model captures functional constraint signals.

Benchmark	Metric	Evo Performance	Notes
Bacterial gene essentiality	AUROC	Discriminates essential vs. non-essential	Log-prob scores reflect functional constraint

Sequence Generation Quality¶

Generated sequences were evaluated for: - Codon usage statistics matching natural genomes - Predicted protein structure quality (using ESMFold) for genes within generated sequences - Realistic genomic organization (operon-like gene arrangements)

Evaluation Criterion	Metric	Result
Protein structure plausibility	ESMFold pTM of encoded ORFs	Generated proteins show plausible folds
Codon usage	KL divergence vs. natural genomes	Comparable to natural prokaryotic sequences
Genomic organization	Operon-like gene clustering	Realistic multi-gene arrangements observed

Note: Exact numerical values require extraction from the paper figures. The above summarizes qualitative findings reported in the text.

BioLM Verification Results¶

Action	Test Input	Tolerance	Status
`log_prob`	"ACGTAC", "ACGTACGTAC"	rel_tol=1e-4	Verified via fixture tests
`generate`	Prompt "ACGT", 100 tokens	Generated sequence check	Verified via fixture tests

Comparison to Alternatives¶

Model	Molecule	Task	When to prefer
Evo	DNA	Generation, scoring	Genome-scale DNA generation; long-context scoring
Nucleotide Transformer	DNA	Embeddings, classification	When you need per-token embeddings for downstream classifiers
DNABERT	DNA	Classification, variant effect	Short regulatory element analysis

Strengths & Limitations¶

Pros¶

Long-context capability: Handles sequences up to 131k nucleotides (with the 131k variant), enabling genome-scale modeling in a single forward pass.
Near-linear scaling: StripedHyena architecture avoids the quadratic memory cost of full attention, making long sequences practical.
Byte-level resolution: Single-nucleotide tokenization preserves full sequence fidelity, critical for mutation-level analysis.
Dual-use (generation + scoring): A single model supports both sequence generation and log-probability scoring without separate fine-tuning.
Diverse training data: OpenGenome covers broad prokaryotic diversity, giving strong generalization across microbial genomes.

Cons¶

Prokaryotic bias: Trained primarily on prokaryotic genomes; eukaryotic sequences (especially large mammalian genomes) are underrepresented.
No embedding extraction endpoint: Unlike ESM2 or Nucleotide Transformer, Evo does not expose per-token embeddings for downstream use.
Large model footprint: At 7B parameters, Evo requires a GPU (L4) and has higher cold-start and inference costs than smaller models.
Generation is stochastic: Generated sequences vary between runs unless a seed is provided, making reproducibility require explicit seed management.

Known Failure Modes¶

Eukaryotic regulatory sequences: Promoters, enhancers, and splicing signals from eukaryotic genomes may be poorly modeled due to training data composition.
Repetitive sequences: Extremely repetitive regions (microsatellites, tandem repeats) may receive unexpectedly high or low scores.
Very short sequences: Sequences under ~10 nucleotides provide minimal context for meaningful log-probability estimates.

Implementation Details¶

Inference Pipeline¶

Request
  |-- 1. Validate input (DNA bases only, length <= 4096)
  |-- 2. Route to action:
  |
  |-- [log_prob]
  |     |-- Tokenize sequences (CharLevelTokenizer)
  |     |-- Forward pass through StripedHyena model
  |     |-- Gather per-position log-probabilities
  |     |-- Sum log-probs across positions per sequence
  |     |-- Return total log-prob per sequence
  |
  |-- [generate]
        |-- Set random seeds (user-provided or time-based)
        |-- Tokenize prompt
        |-- Autoregressive sampling (temperature, top-k, top-p)
        |-- Cached generation for efficiency
        |-- Return generated sequence + average score

Memory & Compute Profile¶

Property	Value
GPU	L4
Memory	8 GB
CPU	4 cores
Model size on disk	~14 GB (FP16 weights)
Cold start	Reduced via Modal memory snapshots (GPU snapshot enabled)

Determinism & Reproducibility¶

log_prob: Deterministic. The forward pass is a pure function of the input with no random components.

generate: Stochastic by default, but reproducible with explicit seed control.

Seed source	Behavior
`seed=None` (default)	Time-based entropy; different output each call
`seed=<int>` (user-provided)	Reproducible output for identical inputs

When a seed is provided, the implementation sets: - 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 serving infrastructure: - Cache key is derived from the full request payload (including parameters) - For generate with no seed (stochastic), cache misses are expected on repeated calls since the time-based seed differs

Versions & Changelog¶

Version	Date	Changes
v1 (weights_version)	2025-02	Initial implementation with `log_prob` and `generate` actions; Evo 1.5-8k-base variant

Biology¶

Molecule Coverage¶

Primary Molecule Type(s)¶

Evo is designed for DNA sequences, operating at single-nucleotide resolution across genomic scales. It was trained on the OpenGenome dataset, which consists primarily of prokaryotic (bacterial and archaeal) whole genomes and bacteriophage sequences.

The model handles: - Prokaryotic genomes: Bacterial and archaeal chromosomes and plasmids -- the core of the training distribution. Evo has strong coverage of diverse microbial taxa. - Bacteriophage genomes: Viral genomes that infect bacteria are well-represented in the training data. - Coding regions: Genes, operons, and coding sequences across diverse organisms. - Non-coding regions: Intergenic sequences, promoters, terminators, and regulatory elements in prokaryotic contexts.

Performance considerations: - Best performance is on prokaryotic DNA, which dominates the training data. - Eukaryotic DNA (plant, animal, fungal genomes) is not the primary training domain. While Evo can process eukaryotic sequences, its learned distribution may not accurately capture eukaryotic-specific features like complex splicing signals, large introns, or distal enhancer-promoter interactions. - The model accepts only unambiguous DNA bases (A, C, G, T). Ambiguity codes (N, R, Y, W, S, etc.) are rejected at the validation layer.

Cross-Applicability¶

Molecule / Domain	Applicability	Evidence	Caveats
Prokaryotic genomes	High	Core training domain (OpenGenome)	Best performance; primary use case
Bacteriophage genomes	High	Included in training data	Phage genomic organization is well-captured
Regulatory elements (prokaryotic)	High	Promoters, RBS, terminators are modeled	Log-prob scoring reflects regulatory constraint
CRISPR systems	High	Specialized fine-tuned variant exists (v1-8k-crispr)	Fine-tuned variant not included in this catalog
Transposable elements	Moderate-High	Specialized fine-tuned variant exists (v1-8k-transposon)	Fine-tuned variant not included in this catalog
Eukaryotic coding regions	Moderate	Codon usage patterns are partially transferable	Eukaryotic codon bias differs from prokaryotic
Eukaryotic regulatory elements	Low	Training data underrepresents eukaryotic regulation	Enhancers, splicing signals, CpG islands poorly modeled
RNA sequences	Not supported	Input validation rejects non-DNA characters (U)	Use RNA-specific models instead
Protein sequences	Not applicable	Evo operates on DNA, not amino acid sequences	Use ESM2 or similar protein language models

Biological Problems Addressed¶

Problem 1: Genome-Scale DNA Sequence Generation¶

Why this matters: Synthetic biology aims to design novel genetic constructs, from individual genes to entire synthetic genomes. Generating biologically plausible DNA sequences at scale is essential for: - Designing synthetic microbial genomes for biotechnology applications - Creating novel genetic circuits with realistic genomic context - Exploring the space of possible genomes for engineering organisms with desired properties

Traditional approaches: - Codon optimization tools generate coding sequences but ignore genomic context (intergenic regions, regulatory elements, genome-wide compositional biases). - Random sequence generation produces biologically implausible DNA. - Template-based design is limited to known natural sequences.

How Evo addresses it: Evo's generate action produces new DNA sequences by sampling from its learned distribution of natural genomic sequences. Given a prompt (a short DNA seed sequence), the model autoregressively generates subsequent nucleotides that are statistically consistent with the patterns observed in real genomes. The generated sequences exhibit: - Realistic codon usage - Plausible open reading frame structures - Genomic organizational features (e.g., operon-like gene arrangements)

Practical considerations: - Generation quality depends on the prompt. A biologically meaningful seed (e.g., the start of a known gene) produces more contextually appropriate continuations. - Temperature and top-k/top-p sampling parameters control the diversity-quality tradeoff. Low temperature (0.0-0.5) produces conservative sequences close to the training distribution; higher temperature increases novelty but may reduce biological plausibility. - Generated sequences should be validated experimentally or computationally (e.g., ORF prediction, structure prediction) before use in synthetic biology applications.

Problem 2: DNA Sequence Fitness Scoring¶

Why this matters: Evaluating whether a DNA sequence is "natural-like" or functionally constrained is fundamental to: - Variant effect prediction: Assessing whether a mutation disrupts function by comparing log-probabilities of wild-type vs. mutant sequences. - Gene essentiality: Regions under strong evolutionary constraint (essential genes, critical regulatory elements) tend to have higher log-probabilities under a well-trained genomic model. - Synthetic sequence evaluation: Scoring designed sequences to assess how well they match the distribution of natural genomes.

Traditional approaches: - Conservation analysis (multiple sequence alignment) requires homologous sequences and is slow for large-scale screening. - Experimental fitness assays (e.g., deep mutational scanning) are accurate but expensive and limited to specific genes.

How Evo addresses it: The log_prob action computes the total log-probability of a DNA sequence under Evo's autoregressive distribution. This score reflects how well the sequence fits the model's learned representation of natural genomic sequences. Higher log-probabilities indicate sequences that are more consistent with the patterns in the training data, which correlates with: - Evolutionary conservation - Functional constraint - Biological plausibility

Interpreting scores: - Log-probabilities are negative values (log of probabilities between 0 and 1). - More negative values indicate less likely sequences. - Scores are summed over all positions, so longer sequences naturally have more negative total log-probs. For length-normalized comparisons, divide by sequence length (the model uses reduce_method="sum" internally). - Relative comparisons (wild-type vs. mutant) are more informative than absolute values.

Problem 3: Gene Regulation and Promoter Design¶

Why this matters: Controlling gene expression is central to synthetic biology, metabolic engineering, and gene therapy. Designing promoters, ribosome binding sites (RBS), and terminators that drive desired expression levels requires understanding the sequence patterns that govern transcription and translation.

How Evo contributes: While Evo is not explicitly trained on regulatory function labels, its autoregressive objective learns the statistical regularities of promoter regions, RBS motifs, and terminator sequences as they appear in natural genomes. This enables: - Scoring regulatory elements: Compare log-probabilities of candidate promoter variants to assess which are most "natural-like." - Generating regulatory sequences: Use generation with appropriate prompts to produce novel regulatory element candidates. - Context-aware design: Unlike motif-based tools, Evo considers the broader genomic context surrounding a regulatory element.

Applied Use Cases¶

Use Case 1: Synthetic Genome Design¶

Source: Nguyen et al. "Sequence modeling and design from molecular to genome scale with Evo." Science (2024). DOI

The Evo paper demonstrated generation of synthetic DNA sequences at genome scale. Generated sequences were evaluated for: - Realistic gene density and operon organization - Protein structure quality of encoded genes (assessed via ESMFold) - Codon usage statistics matching natural prokaryotic genomes

Key finding: Evo-generated sequences encode proteins with plausible predicted structures, suggesting the model has learned not just nucleotide-level statistics but also the higher-order organization of genetic information.

Use Case 2: CRISPR System Design¶

Source: Nguyen et al. "Sequence modeling and design from molecular to genome scale with Evo." Science (2024). DOI

A fine-tuned Evo variant (v1-8k-crispr, not included in this catalog) was applied to generate novel CRISPR-Cas systems. The model produced sequences with: - Correct CRISPR repeat-spacer array organization - Functional Cas protein predictions - Novel CRISPR system architectures not found in existing databases

This demonstrates Evo's potential for designing programmable biological systems.

Predecessor Models¶

Evo 1 (v1-8k-base, v1-131k-base): The original Evo release. Evo 1.5 extends this with ~50% more training data and improved DNA modeling performance. The v1 variants are defined in the codebase but not included in this catalog.

Complementary Models¶

Nucleotide Transformer (NT): Provides per-token DNA embeddings useful for classification tasks. Use NT when you need embeddings for downstream supervised models; use Evo when you need sequence generation or log-probability scoring.
ESM2: Protein language model. For workflows that go from DNA to protein analysis, generate or score DNA with Evo, then translate coding regions and analyze proteins with ESM2.

Alternative Models¶

Alternative	Advantage over Evo	Disadvantage vs Evo
Nucleotide Transformer	Provides per-token embeddings; multiple model sizes	No generation capability; shorter context
DNABERT-2	Strong on regulatory element classification	No generation; limited context length
HyenaDNA	Similar long-context architecture	Smaller model; less training data

Biological Background¶

DNA and Genomics Primer¶

DNA (deoxyribonucleic acid) is the molecule that encodes genetic information in all cellular life and many viruses. It is a polymer 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 the instructions for building and maintaining an organism.

Key concepts relevant to Evo:

Genome: The complete set of DNA sequences in an organism. Bacterial genomes are typically 1-10 million base pairs; human genomes are ~3.2 billion base pairs.
Gene: A segment of DNA that encodes a functional product (usually a protein). Genes are organized into operons in prokaryotes (multiple genes under shared regulatory control).
Regulatory elements: Non-coding DNA sequences that control when and how much a gene is expressed. Include promoters (transcription start signals), ribosome binding sites (translation start signals), and terminators (transcription stop signals).
Codon usage: The genetic code maps nucleotide triplets (codons) to amino acids. Different organisms prefer different codons for the same amino acid -- a pattern called codon usage bias.
Evolutionary constraint: Functionally important DNA regions accumulate mutations more slowly than non-functional regions. This "conservation" signal is what allows sequence models like Evo to distinguish functional from non-functional DNA.

Why DNA language models matter:

Traditional bioinformatics approaches to DNA analysis rely on explicit alignment to known sequences or hand-crafted features (motif databases, position weight matrices). Language models like Evo learn these patterns implicitly from large corpora of genomic sequences, enabling: - Zero-shot analysis: Score or generate sequences without task-specific training data. - Context-dependent evaluation: Consider the full genomic context of a sequence element, not just local motifs. - Generative design: Produce novel DNA sequences that respect the complex, multi-scale statistical structure of natural genomes.

Relevance to applications: - Synthetic biology: Design novel genetic constructs, circuits, and organisms. - Genomics: Interpret genome sequences, predict variant effects, identify functional elements. - Biotechnology: Engineer microorganisms for industrial production, bioremediation, or therapeutics. - Gene therapy: Design optimized gene expression cassettes for therapeutic delivery.

Sources & license¶

License: Apache-2.0 (text)

Papers

Sequence modeling and design from molecular to genome scale with Evo — Science, 2024 · DOI

Source repositories

github: https://github.com/evo-design/evo
github: https://github.com/togethercomputer/stripedhyena

Cite

@article{nguyen2024evo,
  title={Sequence modeling and design from molecular to genome scale with Evo},
  author={Nguyen, Eric and Poli, Michael and Durrant, Matthew G and Kang, Brian and Katrekar, Dhruva and Li, David B and Bartie, Liam J and Thomas, Armin W and King, Samuel H and Brixi, Garyk and Sullivan, Jeremy and Ng, Madelena Y and Lewis, Ashley and Lou, Aaron and Ermon, Stefano and Baccus, Stephen A and Hernandez-Boussard, Tina and R\'{e}, Christopher and Hsu, Patrick D and Hie, Brian L},
  journal={Science},
  year={2024},
  doi={10.1126/science.ado9336}
}

Evo¶

At a glance¶

API & schema¶

log_prob¶

generate¶

Usage¶

Overview¶

Architecture¶

Capabilities & Limitations¶

Usage Examples¶

Score DNA sequences¶

Generate DNA sequences¶

Architecture & training¶

Architecture¶

Model Type & Innovation¶

Parameters & Layers¶

Training Data¶

Loss Function & Objective¶

Tokenization / Input Processing¶

Performance & Benchmarks¶

Published Benchmarks¶

Zero-Shot Fitness Prediction¶

Gene Essentiality Prediction¶

Sequence Generation Quality¶

BioLM Verification Results¶

Comparison to Alternatives¶

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: Genome-Scale DNA Sequence Generation¶

Problem 2: DNA Sequence Fitness Scoring¶

Problem 3: Gene Regulation and Promoter Design¶

Applied Use Cases¶

Use Case 1: Synthetic Genome Design¶

Use Case 2: CRISPR System Design¶

Related Models¶

Predecessor Models¶

Complementary Models¶

Alternative Models¶

Biological Background¶

DNA and Genomics Primer¶

Sources & license¶

`log_prob`¶

`generate`¶