ESM C¶

Protein representation model from EvolutionaryScale (ESM Cambrian) providing high-quality embeddings, masked token prediction, and sequence log-probability scoring in a 300M parameter variant.

License: MIT · Molecules: protein · Tasks: embedding, sequence_completion, property_prediction

Actions: encode, predict, log_prob · Variants: 1

At a glance¶

Use it when

You need high-quality protein embeddings with better parameter efficiency than ESM2, especially when GPU memory is constrained but you want near-3B-level quality
You are building a new protein ML pipeline and want the latest-generation ESM embeddings without legacy constraints
You need sequence fitness scoring (log_prob) for variant prioritization and want improved evolutionary signal from newer training data
You want masked token prediction for sequence design or variant effect estimation with state-of-the-art single-sequence accuracy
You are fine-tuning or performing transfer learning on limited labeled data and want the latest-generation ESM embeddings with improved evolutionary signal from newer training data

Strengths

Higher parameter efficiency than ESM2 — ESMC-300M surpasses ESM2-650M on multiple benchmarks with significantly fewer parameters (EvolutionaryScale's 600M variant, also MIT and not distributed here, approaches ESM2-3B quality)
The 300M variant runs on A10G GPUs and is suitable for high-throughput screening while surpassing ESM2-650M on multiple benchmarks
Transfer learning benchmark (Nature Scientific Reports, 2025) showed ESMC-600M (upstream; also MIT, not distributed here) offers an optimal balance between performance and efficiency, matching larger models on limited-data regimes
Full action repertoire — encode (embeddings), predict (masked token prediction), and log_prob (sequence fitness scoring) — covers the same use cases as ESM2 in a single model
Trained on the latest protein databases with updated training procedures, potentially capturing more recent evolutionary patterns than ESM2 (2023 training data)
Demonstrated strong antibody engineering results — CDR-focused fine-tuning of ESMC-600M (upstream; also MIT, not distributed here) matched or exceeded 3B-parameter antibody-specific baselines with 5x fewer parameters
Supports sequences up to 2048 residues with all 20 standard amino acids plus extended characters and gaps
Applied literature shows ESMC embeddings capture emergent structural features useful for electrostatic property prediction (pKa) despite being a sequence-only model

Limitations

Smaller ecosystem of downstream fine-tuned models compared to ESM2 — no ESMC-specific structure predictor (ESMFold uses ESM2), stability predictor, or toxicity predictor yet
Fewer independent benchmark validations than ESM2, which has been evaluated across hundreds of published studies since 2023
Only one distributed size variant (300M) — lacks the extreme scaling range of ESM2 (8M-3B), particularly missing a CPU-friendly small variant and a maximum-quality large variant; EvolutionaryScale's 600M variant exists upstream but is also MIT and not distributed here
No structure awareness — purely sequence-based, outperformed by structure-aware models such as ProstT5 on tasks where structural information is available
Single-chain only — no explicit modeling of protein complexes or multi-chain interactions
Primary announcement is a blog post rather than a peer-reviewed paper, limiting formal methodological scrutiny

Reach for something else when

You need a permissive MIT license for unrestricted commercial deployment — use ESM2 instead, which has no licensing restrictions
You need compatibility with the extensive ecosystem of ESM2-based downstream tools (ESMFold and others) that expect ESM2-specific embedding dimensions and formats
You need a CPU-only model for edge deployment or extremely cost-sensitive screening — ESM2 8M and 35M variants run on CPU; ESMC requires GPU
You need structure-aware protein representations — use ProstT5 (with 3Di structural tokens) when structural information is available
You are reproducing published results that specifically used ESM2 embeddings and need exact comparability
You need the absolute largest model available — ESM2-3B provides more raw parameters than the distributed ESMC-300M, with diminishing returns for most tasks

Alternatives

Model	Better when	Worse when
esm2	Far more published benchmarks, five size variants spanning CPU-only 8M to 3B, and an established ecosystem of ESM2-based downstream tools; the safer production default.	esmc reaches comparable embedding quality with fewer parameters (300M surpasses ESM2-650M), from newer training data.
esm1b	esm1b is essentially never strictly better; it is an earlier generation kept for reproducing legacy ESM-1b results.	esmc is two generations ahead with superior representations, higher parameter efficiency, and longer context (2048 vs 1022 residues).
prostt5	Adds structure awareness — bidirectional AA<->3Di translation and structure-informed embeddings that capture fold-level information esmc's pure-sequence embeddings miss.	esmc gives richer sequence-only outputs (mean/per-residue embeddings, logits, log_prob) and masked prediction; ProstT5's structure mode needs 3Di tokens and it lacks a fitness log_prob action.
esm1v	Purpose-built zero-shot variant-effect predictor: a 5-member ensemble returning ranked amino-acid substitution scores at a masked position, a task-specific output that esmc's raw predict logits would need post-processing to match.	esmc adds embeddings (encode) and whole-sequence fitness scoring (log_prob) beyond masked prediction, supports 2048 vs 1022 residues, allows multiple masks, and is a newer more parameter-efficient generation; esm1v only exposes single-masked-position predict.

API & schema¶

Variants

Variant	Endpoint slug	GPU	CPU	Memory
300m	`esmc-300m`	a10g	2.0	24 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/esmc-300m/encode \
  -H "Content-Type: application/json" \
  -d '{
  "items": [
    {
      "sequence": "MKTAYIAKQRQISFVKSHFSRQLEERLGLIE"
    }
  ]
}'

Request — ESMCEncodeRequest

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

Nested types

ESMCEncodeIncludeOptions

Allowed values: mean, per_residue, per_residue, logits

ESMCEncodeRequestItem

Field	Type	Required	Constraints	Description
`sequence`	string	yes	len 1–2048	A protein sequence in single-letter amino-acid codes; gap characters (-) are accepted.

ESMCEncodeRequestParams

Field	Type	Required	Constraints	Description
`repr_layers`	list[integer]	no	default `[-1]`	Hidden layers whose representations to return (negative indexes count from the last layer).
`include`	list[ESMCEncodeIncludeOptions]	no	default `['mean']`	Optional outputs to compute and include in the response.

Raw JSON Schema

{
  "$defs": {
    "ESMCEncodeIncludeOptions": {
      "enum": [
        "mean",
        "per_residue",
        "per_residue",
        "logits"
      ],
      "title": "ESMCEncodeIncludeOptions",
      "type": "string"
    },
    "ESMCEncodeRequestItem": {
      "additionalProperties": false,
      "properties": {
        "sequence": {
          "description": "A protein sequence in single-letter amino-acid codes; gap characters (-) are accepted.",
          "maxLength": 2048,
          "minLength": 1,
          "title": "Sequence",
          "type": "string"
        }
      },
      "required": [
        "sequence"
      ],
      "title": "ESMCEncodeRequestItem",
      "type": "object"
    },
    "ESMCEncodeRequestParams": {
      "additionalProperties": false,
      "properties": {
        "repr_layers": {
          "description": "Hidden layers whose representations to return (negative indexes count from the last layer).",
          "items": {
            "type": "integer"
          },
          "title": "Repr Layers",
          "type": "array",
          "default": [
            -1
          ]
        },
        "include": {
          "description": "Optional outputs to compute and include in the response.",
          "items": {
            "$ref": "#/$defs/ESMCEncodeIncludeOptions"
          },
          "title": "Include",
          "type": "array",
          "default": [
            "mean"
          ]
        }
      },
      "title": "ESMCEncodeRequestParams",
      "type": "object"
    }
  },
  "additionalProperties": false,
  "properties": {
    "params": {
      "$ref": "#/$defs/ESMCEncodeRequestParams",
      "description": "Optional parameters controlling this action (defaults are used when omitted)."
    },
    "items": {
      "description": "Batch of inputs to process in a single request. Up to 8 sequences per request.",
      "items": {
        "$ref": "#/$defs/ESMCEncodeRequestItem"
      },
      "maxItems": 8,
      "minItems": 1,
      "title": "Items",
      "type": "array"
    }
  },
  "required": [
    "items"
  ],
  "title": "ESMCEncodeRequest",
  "type": "object"
}

Response — ESMCEncodeResponse

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

Nested types

ESMCEncodeResponseResult

Field	Type	Required	Description
`embeddings`	list[LayerEmbedding] \| null	no	Mean-pooled embedding vectors for each requested layer.
`residue_embeddings`	list[LayerPerTokenEmbeddings] \| null	no	Per-residue embedding vectors.
`logits`	list[list[number]] \| null	no	Per-position logits over the model vocabulary.
`vocab_tokens`	list[string] \| null	no	Vocabulary token order corresponding to the logits columns.

LayerEmbedding

Field	Type	Required	Constraints	Description
`layer`	integer	yes		Model layer this representation was taken from.
`embedding`	list[number]	yes		Mean-pooled embedding vector for the sequence.

LayerPerTokenEmbeddings

Field	Type	Required	Constraints	Description
`layer`	integer	yes		Model layer this representation was taken from.
`embeddings`	list[list[number]]	yes		Per-residue embedding vectors for this layer, one vector per sequence position (BOS/EOS excluded).

Raw JSON Schema

{
  "$defs": {
    "ESMCEncodeResponseResult": {
      "exclude_none": true,
      "exclude_unset": true,
      "properties": {
        "embeddings": {
          "anyOf": [
            {
              "items": {
                "$ref": "#/$defs/LayerEmbedding"
              },
              "type": "array"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Mean-pooled embedding vectors for each requested layer.",
          "title": "Embeddings"
        },
        "residue_embeddings": {
          "anyOf": [
            {
              "items": {
                "$ref": "#/$defs/LayerPerTokenEmbeddings"
              },
              "type": "array"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Per-residue embedding vectors.",
          "title": "Residue Embeddings"
        },
        "logits": {
          "anyOf": [
            {
              "items": {
                "items": {
                  "type": "number"
                },
                "type": "array"
              },
              "type": "array"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Per-position logits over the model vocabulary.",
          "title": "Logits"
        },
        "vocab_tokens": {
          "anyOf": [
            {
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Vocabulary token order corresponding to the logits columns.",
          "title": "Vocab Tokens"
        }
      },
      "title": "ESMCEncodeResponseResult",
      "type": "object"
    },
    "LayerEmbedding": {
      "properties": {
        "layer": {
          "description": "Model layer this representation was taken from.",
          "title": "Layer",
          "type": "integer"
        },
        "embedding": {
          "description": "Mean-pooled embedding vector for the sequence.",
          "items": {
            "type": "number"
          },
          "title": "Embedding",
          "type": "array"
        }
      },
      "required": [
        "layer",
        "embedding"
      ],
      "title": "LayerEmbedding",
      "type": "object"
    },
    "LayerPerTokenEmbeddings": {
      "properties": {
        "layer": {
          "description": "Model layer this representation was taken from.",
          "title": "Layer",
          "type": "integer"
        },
        "embeddings": {
          "description": "Per-residue embedding vectors for this layer, one vector per sequence position (BOS/EOS excluded).",
          "items": {
            "items": {
              "type": "number"
            },
            "type": "array"
          },
          "title": "Embeddings",
          "type": "array"
        }
      },
      "required": [
        "layer",
        "embeddings"
      ],
      "title": "LayerPerTokenEmbeddings",
      "type": "object"
    }
  },
  "properties": {
    "results": {
      "description": "Per-input results, returned in the same order as the request items.",
      "items": {
        "$ref": "#/$defs/ESMCEncodeResponseResult"
      },
      "title": "Results",
      "type": "array"
    }
  },
  "required": [
    "results"
  ],
  "title": "ESMCEncodeResponse",
  "type": "object"
}

`predict`¶

Call it

curl -X POST http://127.0.0.1:8000/api/v1/esmc-300m/predict \
  -H "Content-Type: application/json" \
  -d '{
  "items": [
    {
      "sequence": "MKTAYIAKQRQISFVKSHFSRQLEERLGLIE"
    }
  ]
}'

Request — ESMCPredictRequest

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

Nested types

ESMCPredictRequestItem

Field	Type	Required	Constraints	Description
`sequence`	string	yes	len 1–2048	A protein sequence in single-letter amino-acid codes with one or more tokens indicating positions to predict.

Raw JSON Schema

{
  "$defs": {
    "ESMCPredictRequestItem": {
      "additionalProperties": false,
      "properties": {
        "sequence": {
          "description": "A protein sequence in single-letter amino-acid codes with one or more <mask> tokens indicating positions to predict.",
          "maxLength": 2048,
          "minLength": 1,
          "title": "Sequence",
          "type": "string"
        }
      },
      "required": [
        "sequence"
      ],
      "title": "ESMCPredictRequestItem",
      "type": "object"
    }
  },
  "additionalProperties": false,
  "properties": {
    "items": {
      "description": "Batch of inputs to process in a single request. Up to 8 sequences per request.",
      "items": {
        "$ref": "#/$defs/ESMCPredictRequestItem"
      },
      "maxItems": 8,
      "minItems": 1,
      "title": "Items",
      "type": "array"
    }
  },
  "required": [
    "items"
  ],
  "title": "ESMCPredictRequest",
  "type": "object"
}

Response — ESMCPredictResponse

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

Nested types

ESMCPredictResponseResult

Field	Type	Required	Description
`logits`	list[list[number]]	yes	Per-position logits over the model vocabulary.
`sequence_tokens`	list[string]	yes	Per-position input tokens, aligned with the logits.
`vocab_tokens`	list[string]	yes	Vocabulary token order corresponding to the logits columns.

Raw JSON Schema

{
  "$defs": {
    "ESMCPredictResponseResult": {
      "properties": {
        "logits": {
          "description": "Per-position logits over the model vocabulary.",
          "items": {
            "items": {
              "type": "number"
            },
            "type": "array"
          },
          "title": "Logits",
          "type": "array"
        },
        "sequence_tokens": {
          "description": "Per-position input tokens, aligned with the logits.",
          "items": {
            "type": "string"
          },
          "title": "Sequence Tokens",
          "type": "array"
        },
        "vocab_tokens": {
          "description": "Vocabulary token order corresponding to the logits columns.",
          "items": {
            "type": "string"
          },
          "title": "Vocab Tokens",
          "type": "array"
        }
      },
      "required": [
        "logits",
        "sequence_tokens",
        "vocab_tokens"
      ],
      "title": "ESMCPredictResponseResult",
      "type": "object"
    }
  },
  "properties": {
    "results": {
      "description": "Per-input results, returned in the same order as the request items.",
      "items": {
        "$ref": "#/$defs/ESMCPredictResponseResult"
      },
      "title": "Results",
      "type": "array"
    }
  },
  "required": [
    "results"
  ],
  "title": "ESMCPredictResponse",
  "type": "object"
}

`log_prob`¶

Call it

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

Request — ESMCLogProbRequest

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

Nested types

ESMCLogProbRequestItem

Field	Type	Required	Constraints	Description
`sequence`	string	yes	len 1–2048	A protein sequence in single-letter amino-acid codes; only the 20 unambiguous amino acids are accepted.

Raw JSON Schema

{
  "$defs": {
    "ESMCLogProbRequestItem": {
      "additionalProperties": false,
      "properties": {
        "sequence": {
          "description": "A protein sequence in single-letter amino-acid codes; only the 20 unambiguous amino acids are accepted.",
          "maxLength": 2048,
          "minLength": 1,
          "title": "Sequence",
          "type": "string"
        }
      },
      "required": [
        "sequence"
      ],
      "title": "ESMCLogProbRequestItem",
      "type": "object"
    }
  },
  "additionalProperties": false,
  "properties": {
    "items": {
      "description": "Batch of inputs to process in a single request. Up to 8 sequences per request.",
      "items": {
        "$ref": "#/$defs/ESMCLogProbRequestItem"
      },
      "maxItems": 8,
      "minItems": 1,
      "title": "Items",
      "type": "array"
    }
  },
  "required": [
    "items"
  ],
  "title": "ESMCLogProbRequest",
  "type": "object"
}

Response — ESMCLogProbResponse

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

Nested types

ESMCLogProbResponseResult

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

Raw JSON Schema

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

Usage¶

One-line summary: Protein representation model from EvolutionaryScale (ESM Cambrian) providing high-quality embeddings, masked token prediction, and sequence log-probability scoring in a 300M parameter variant.

Overview¶

ESM C (ESM Cambrian) is the latest generation of protein language models from EvolutionaryScale (2024). It provides highly effective embeddings and logits for protein sequences, surpassing older ESM2 models on many benchmarks with improved parameter efficiency. The 300M variant surpasses ESM2-650M. EvolutionaryScale also publishes a 600M variant (also MIT; not distributed in this catalog).

Three actions are available: encode for extracting embeddings and logits, predict for masked token prediction, and log_prob for computing sequence fitness scores.

Architecture¶

Property	Value
Architecture	Transformer (optimized for proteins)
300M variant	~300M parameters
Max sequence length	2048 residues
Software package	`esm==3.1.3`
Input	Amino acid sequences
Output	Embeddings, per-token logits, log-probabilities

Capabilities & Limitations¶

CAN be used for: - Extracting mean-pooled or per-token protein embeddings at any Transformer layer - Computing per-position logits restricted to 20 canonical amino acids - Predicting amino acid probabilities at masked positions (one or more masks) - Computing total sequence log-probability as a fitness proxy - Batch processing up to 8 sequences per request - Handling sequences with gap characters (-) in the encode action

CANNOT be used for: - Sequences longer than 2048 residues - Nucleic acid sequences (protein-only model) - Structure prediction directly (use ESMFold or Chai-1) - Generating new protein sequences (use generative models like ProGen2 or Evo) - Non-canonical amino acid handling in log_prob (requires standard 20 only)

Usage Examples¶

Extract mean embeddings¶

from models.esmc.schema import (
    ESMCEncodeRequest,
    ESMCEncodeRequestItem,
    ESMCEncodeRequestParams,
    ESMCEncodeIncludeOptions,
)

request = ESMCEncodeRequest(
    params=ESMCEncodeRequestParams(
        repr_layers=[-1],
        include=[ESMCEncodeIncludeOptions.MEAN],
    ),
    items=[
        ESMCEncodeRequestItem(
            sequence="TPSSKEMMSQALKATFSGFTKEQQRLGIPKDPRQWTETHVRDWVMWAVNEFSLKGVDFQKF"
        )
    ],
)

Extract per-token embeddings and logits¶

from models.esmc.schema import (
    ESMCEncodeRequest,
    ESMCEncodeRequestItem,
    ESMCEncodeRequestParams,
    ESMCEncodeIncludeOptions,
)

request = ESMCEncodeRequest(
    params=ESMCEncodeRequestParams(
        repr_layers=[-1],
        include=[
            ESMCEncodeIncludeOptions.PER_TOKEN,
            ESMCEncodeIncludeOptions.LOGITS,
        ],
    ),
    items=[
        ESMCEncodeRequestItem(sequence="MKTAYVNNKELSKDVR")
    ],
)

Predict masked positions¶

from models.esmc.schema import (
    ESMCPredictRequest,
    ESMCPredictRequestItem,
)

request = ESMCPredictRequest(
    items=[
        ESMCPredictRequestItem(
            sequence="MKTAY<mask>NNKELSKDVR"
        )
    ],
)

Compute sequence log-probability¶

from models.esmc.schema import (
    ESMCLogProbRequest,
    ESMCLogProbRequestItem,
)

request = ESMCLogProbRequest(
    items=[
        ESMCLogProbRequestItem(
            sequence="TPSSKEMMSQALKATFSGFTKEQQRLGIPKDPRQWTETHVRDWVMWAVNEFSLKGVDFQKF"
        )
    ],
)

Architecture & training¶

Architecture¶

Model Type & Innovation¶

ESM C (ESM Cambrian) is the latest generation of protein representation models from EvolutionaryScale (2024). It represents a significant advancement over the ESM2 family, achieving comparable or superior performance with substantially fewer parameters and more efficient inference. The "Cambrian" name references the Cambrian explosion of biodiversity, reflecting the model's improved ability to capture the diversity of protein sequence space.

ESM C uses a Transformer architecture optimized for protein sequences, with improvements in training procedure, tokenization, and model scaling that yield better embeddings than ESM2 at equivalent or smaller model sizes. EvolutionaryScale also publishes a 600M variant (also MIT) that approaches the quality of ESM2-3B; it is not distributed in this catalog.

Parameters & Layers¶

Component	Details
Architecture	Transformer (optimized for proteins)
300M variant	~300M parameters
Input	Amino acid sequences (up to 2048 residues)
Output	Per-residue embeddings, logits over vocabulary, log-probabilities
Tokenizer	ESM Cambrian tokenizer (20 canonical amino acids + special tokens)
Hidden states	Available at each Transformer layer

Training Data¶

Property	Details
Training approach	Large-scale protein language model training
Source	EvolutionaryScale proprietary training pipeline
Scope	Broad protein sequence databases

Loss Function & Objective¶

ESM C is trained with a language modeling objective optimized for protein sequences. The specific training details are described in the EvolutionaryScale blog post and associated technical documentation.

Tokenization / Input Processing¶

Input format: Amino acid sequence strings
Encode action: Accepts extended amino acid alphabet plus gap character (-)
Predict action: Accepts extended amino acid alphabet plus <mask> token, requires one or more <mask> tokens
Predict log prob action: Accepts only the 20 unambiguous amino acids (no mask, no gaps)
Maximum length: 2048 residues
Special tokens: BOS (beginning of sequence) and EOS (end of sequence) tokens are added automatically and removed from output embeddings/logits

Performance & Benchmarks¶

Published Benchmarks¶

From the EvolutionaryScale blog post (2024):

Model	Parameters	Benchmark Performance
ESMC-300M	300M	Surpasses ESM2-650M on multiple benchmarks
ESMC-600M (upstream)	600M	Approaches ESM2-3B quality (also MIT; not distributed here)
ESM2-650M	650M	Established baseline
ESM2-3B	3B	Previous state-of-the-art open model

BioLM Verification Results¶

Variant	Action	Tolerance	Status
300m	encode (test 1)	cosine_distance < 0.02, rel_tol 1e-4	PASS
300m	encode (test 2)	cosine_distance < 0.02, rel_tol 1e-4	PASS
300m	predict	cosine_distance < 0.02, rel_tol 1e-4	PASS
300m	log_prob	Negative finite value validation	PASS

Comparison to Alternatives¶

Model	Strength	When to prefer
ESMC-300M	Efficient, surpasses ESM2-650M	Quick prototyping, resource-constrained
ESM2-650M	Well-established, widely benchmarked	Backward compatibility with existing pipelines
ESM2-3B	Largest ESM2 model	Maximum ESM2-era quality
ESM1v	Variant effect prediction specialist	Specifically optimized for mutation effect scoring

Strengths & Limitations¶

Pros¶

Better parameter efficiency than ESM2 (more performance per parameter)
Three distinct actions: embeddings, masked prediction, sequence log-probability
Multi-layer embedding extraction with user-specified layers
Mean-pooled, per-token, and logit outputs available from encode
Log-probability scoring for sequence fitness assessment
Efficient 300M model surpassing ESM2-650M on multiple benchmarks
Supports gap character (-) in encode for alignment-aware embeddings

Cons¶

Maximum sequence length of 2048 residues
Predict action requires at least one <mask> token
No ensemble mode (unlike ESM1v with 5 models)
Relatively new model with less published benchmarking than ESM2

Known Failure Modes¶

Sequences near or exceeding 2048 residues may be truncated
Requesting layer indices outside the valid range raises a ValidationError400 (HTTP 400)
Predict_log_prob only considers 20 canonical amino acids; sequences with non-standard residues will have those positions excluded
Very short sequences (<5 residues) may produce low-quality embeddings

Implementation Details¶

Inference Pipeline¶

Encode¶

Request
  |-- 1. Validate sequences (extended AA + gap)
  |-- 2. Tokenize sequences with ESMC tokenizer
  |-- 3. Batched forward pass
  |-- 4. For each requested layer:
  |     |-- [if mean] Mean-pool hidden states (excluding BOS/EOS)
  |     |-- [if per_token] Extract per-residue embeddings (excluding BOS/EOS)
  |-- 5. [if logits] Slice sequence_logits to 20 canonical AAs
  |-- 6. Format and return response

Predict¶

Request
  |-- 1. Validate sequences (extended AA + <mask>)
  |-- 2. Tokenize and forward pass
  |-- 3. Remove BOS/EOS from logits
  |-- 4. Slice to 20 canonical AAs
  |-- 5. Detokenize to get sequence tokens
  |-- 6. Return logits, sequence_tokens, vocab_tokens

Predict Log Prob¶

Request
  |-- 1. Validate sequences (unambiguous AA only)
  |-- 2. Tokenize and forward pass
  |-- 3. For each position in sequence:
  |     |-- Gather logits for 20 canonical AAs
  |     |-- Compute log-softmax over canonical AAs
  |     |-- Add log-prob of actual residue to sum
  |-- 4. Return total log-probability per sequence

Memory & Compute Profile¶

Resource	300M Variant
GPU	A10G
Memory	24 GB RAM
CPU	2.0 cores
Batch size	8
Max sequence length	2048

Determinism & Reproducibility¶

Setting	Value
Torch manual seed	Yes (42 at model load)
CUDA manual seed	Yes (42, if available)
Deterministic outputs	Yes (all three actions are deterministic)

Caching Behavior¶

Response caching is handled outside the model container: - In-memory caching for fast repeated lookups within a container lifetime - Persistent storage caching for cross-request reuse - Cache keys determined by full request payload (sequences + parameters)

Versions & Changelog¶

Version	Date	Changes
v1	2024	Initial implementation with encode, predict, log_prob actions

Biology¶

Molecule Coverage¶

Primary Molecule Type(s)¶

ESM C is a general-purpose protein representation model that works across all protein types. It was trained on broad protein sequence databases and produces high-quality embeddings, per-token logits, and sequence log-probabilities applicable to diverse biological problems.

Important coverage notes: - Works with any protein sequence up to 2048 residues - Supports all 20 standard amino acids plus extended characters and gaps - Trained on diverse protein families covering the known proteome - Not specialized for any particular protein family but broadly applicable

Cross-Applicability¶

Molecule Type	Applicability	Evidence	Caveats
Globular proteins	High	Primary training target	Standard application
Enzymes	High	Well-represented in training data	Active site may need specialized analysis
Antibodies	High	Present in training data	Use AbLEF/AntiFold for antibody-specific tasks
Membrane proteins	Moderate-High	Present in training data	Transmembrane topology not explicitly modeled
Peptides	Moderate	Short sequences have less context	Works for peptides >~10 residues
Disordered proteins	Moderate	Present in training data	Disordered regions have less sequence conservation
Viral proteins	Moderate-High	Present in training data	Rapidly evolving proteins may benefit from MSA-based methods
Nucleic acids	Not applicable	Protein-only model	Use DNABERT2 or nucleotide transformer

Biological Problems Addressed¶

Protein Representation and Feature Extraction (Published)¶

Biological context: Many computational biology tasks require representing proteins as fixed-dimensional vectors for downstream machine learning. The quality of these representations fundamentally affects performance on tasks such as function prediction, localization prediction, family classification, and interaction prediction. Traditional approaches used hand-crafted features (amino acid composition, physicochemical properties) or evolutionary features (MSA profiles), but protein language models provide richer, context-aware representations learned from millions of sequences.

How ESMC helps: The encode action produces embeddings at multiple granularities: - Mean-pooled embeddings: A single vector per sequence (dimension depends on model variant) for sequence-level tasks like classification or clustering - Per-token embeddings: A vector per residue for position-level tasks like secondary structure prediction, binding site prediction, or disorder prediction - Logits: Per-position probability distributions over amino acids for analyzing sequence preferences

Users can request embeddings from any Transformer layer via repr_layers, enabling multi-scale feature extraction. Negative indices are supported (e.g., -1 for the last layer).

Output interpretation: Embeddings can be used directly as features for supervised learning, clustering, or similarity search. Mean-pooled embeddings capture global sequence properties, while per-token embeddings capture local sequence context. The last layer typically captures the most task-relevant features, while earlier layers may capture more local patterns.

Masked Token Prediction and Sequence Design (Published)¶

Biological context: Understanding which amino acids are compatible at each position in a protein sequence is valuable for multiple tasks: identifying positions tolerant to mutation, predicting the effects of variants, and designing new sequences. Masked language models learn this information implicitly during training by predicting randomly masked positions from their sequence context.

How ESMC helps: The predict action accepts sequences with one or more <mask> tokens and returns the model's per-token logits restricted to the 20 canonical amino acids. This enables: - Variant effect prediction (compare wild-type vs mutant log-likelihoods) - Filling in unknown residues in partial sequences - Generating position-specific scoring matrices (PSSMs) from a single sequence

Output interpretation: The logits field contains a 2D array (sequence_length x 20) of raw logits. Higher logits indicate amino acids more compatible with the sequence context. The sequence_tokens field shows the decoded sequence, and vocab_tokens maps the 20 columns to amino acid identities.

Sequence Fitness Scoring (Published)¶

Biological context: Assessing the overall "fitness" or "naturalness" of a protein sequence is useful for evaluating designed sequences, scoring variant libraries, and filtering computationally generated candidates. A sequence that deviates significantly from the statistical patterns learned from natural sequences is more likely to be non-functional.

How ESMC helps: The log_prob action computes the total log-probability of an unmasked sequence, summing over all positions. This provides a single scalar score that reflects how well the sequence matches the patterns learned from the training data. More negative values indicate less "natural" sequences.

Output interpretation: The log-probability is always negative (or zero for a theoretically perfect sequence). Relative comparisons are more meaningful than absolute values: comparing log-probabilities of a wild-type sequence versus a mutant, or ranking a library of designed sequences by their log-probabilities. Note that log-probabilities are computed over only the 20 canonical amino acids at each position.

Protein Property Prediction (Anticipated)¶

Biological context: Many protein properties of practical interest -- stability, solubility, expression level, binding affinity -- correlate with sequence features that can be captured by protein language model embeddings. Using ESMC embeddings as features for supervised models can yield property predictors that generalize better than models trained on raw sequence features alone.

How ESMC helps: ESMC embeddings can serve as the input layer for task-specific prediction models. For example, a simple linear model trained on ESMC embeddings and labeled stability data could predict the thermal stability of novel sequences. The improved embedding quality of ESMC over ESM2 should translate to better downstream prediction performance. However, this application depends on having labeled training data for the property of interest.

Applied Use Cases¶

ESM C was released in late 2024 and the applied literature is still emerging. The ESM model family broadly has been used in hundreds of published studies for protein engineering, variant interpretation, and function prediction. See sources.yaml for known applied literature entries.

Predecessor Models¶

ESM2 (Lin et al., 2023): The previous generation of ESM protein language models. ESM2 was trained on UniRef50 and is available in sizes from 8M to 15B parameters. ESMC improves on ESM2's parameter efficiency, achieving comparable performance with fewer parameters.
ESM-1b (Rives et al., 2021): The original large-scale ESM model (650M parameters). ESMC represents two generations of improvement.

Complementary Models¶

ESMC works well in combination with other models in this catalog:

ESMFold: Uses ESM2 embeddings for structure prediction. ESMC embeddings may be useful in similar structure prediction pipelines.
ESM1v: Specialized for variant effect prediction. ESMC's predict and log_prob actions provide alternative (potentially superior) variant scoring.
AbLEF: Uses AbLang embeddings for antibody developability. ESMC embeddings could serve a similar role for general proteins.
Structure prediction models (ESMFold, Chai-1): ESMC embeddings can complement structural features for integrated analysis.

Alternative Models¶

Alternative	Advantage over ESMC	Disadvantage vs ESMC
ESM2-650M	Well-established, widely benchmarked	Lower parameter efficiency
ESM2-3B	Larger model, more capacity	EvolutionaryScale's 600M variant (also MIT; not distributed here) approaches ESM2-3B quality; the distributed 300M variant surpasses ESM2-650M
ESM1v	Specifically optimized for variant effects	Only variant prediction, no embeddings
ProtTrans (ProtT5)	Available through HuggingFace	Older architecture, lower efficiency

Biological Background¶

Protein Language Models¶

Protein language models apply natural language processing techniques to amino acid sequences, treating proteins as "sentences" in a 20-letter "language." By training on millions of natural protein sequences, these models learn statistical patterns that encode evolutionary information about protein structure, function, and fitness. The key insight is that positions in a protein sequence are not independent -- they co-evolve due to structural contacts, functional constraints, and phylogenetic relationships. Language models capture these dependencies in their learned representations.

Embeddings for Proteins¶

A protein embedding is a dense vector representation of a protein sequence that captures biologically relevant information in a form suitable for computational analysis. Good embeddings have the property that proteins with similar functions, structures, or evolutionary origins have similar embeddings (close in vector space). ESMC produces:

Sequence-level (mean) embeddings: Capture global sequence properties. Useful for comparing proteins, clustering, or predicting sequence-level properties.
Residue-level (per-token) embeddings: Capture the local context of each amino acid. Useful for predicting residue-level properties (secondary structure, solvent accessibility, binding sites).

Sequence Log-Probability as Fitness Proxy¶

The total log-probability of a protein sequence under a language model serves as a proxy for evolutionary fitness. Sequences with high log-probability are more "natural" -- they resemble the patterns found in the training data (millions of natural sequences shaped by evolution). This is biologically meaningful because evolution selects for functional sequences, so the statistical patterns in natural sequences encode functional constraints. A mutation that reduces the sequence's log-probability is more likely to be deleterious, while mutations that maintain or increase it are more likely to be tolerated.

ESM Model Evolution¶

The ESM (Evolutionary Scale Modeling) family of protein language models has progressed through several generations:

ESM-1b (2021): First large-scale protein language model (650M parameters)
ESM1v (2021): Variant effect prediction specialist (5x650M ensemble)
ESM2 (2023): Improved architecture, multiple sizes (8M--15B)
ESM C (2024, Cambrian): Latest generation with improved parameter efficiency

Each generation has improved the quality of learned representations while the underlying principle remains the same: learning the statistical structure of natural protein sequences to capture biologically meaningful patterns.

Sources & license¶

License: MIT (text) — The entire ESM/ESMC family (including model weights) was re-released under the standard MIT License by Chan Zuckerberg Biohub in May 2026 (Copyright 2026 Chan Zuckerberg Biohub, Inc.), superseding the former EvolutionaryScale Cambrian Open License Agreement. Commercial and non-commercial use is permitted; the "Built with ESM" attribution and "ESM"-prefixed naming requirements no longer apply.

Papers

ESM Cambrian: Revealing the mysteries of proteins with unsupervised learning — EvolutionaryScale blog post (not a peer-reviewed paper), 2024

Source repositories

github: https://github.com/evolutionaryscale/esm
huggingface: https://huggingface.co/EvolutionaryScale/esmc-300m-2024-12
other: https://www.evolutionaryscale.ai/blog/esm-cambrian

Cite

@misc{esmc2024,
  title={ESM Cambrian: Revealing the mysteries of proteins with unsupervised learning},
  author={EvolutionaryScale Team},
  year={2024},
  url={https://www.evolutionaryscale.ai/blog/esm-cambrian}
}

ESM C¶

At a glance¶

API & schema¶

encode¶

predict¶

log_prob¶

Usage¶

Overview¶

Architecture¶

Capabilities & Limitations¶

Usage Examples¶

Extract mean embeddings¶

Extract per-token embeddings and logits¶

Predict masked positions¶

Compute sequence log-probability¶

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¶

Strengths & Limitations¶

Pros¶

Cons¶

Known Failure Modes¶

Implementation Details¶

Inference Pipeline¶

Encode¶

Predict¶

Predict Log Prob¶

Memory & Compute Profile¶

Determinism & Reproducibility¶

Caching Behavior¶

Versions & Changelog¶

Biology¶

Molecule Coverage¶

Primary Molecule Type(s)¶

Cross-Applicability¶

Biological Problems Addressed¶

Protein Representation and Feature Extraction (Published)¶

Masked Token Prediction and Sequence Design (Published)¶

Sequence Fitness Scoring (Published)¶

Protein Property Prediction (Anticipated)¶

Applied Use Cases¶

Related Models¶

Predecessor Models¶

Complementary Models¶

Alternative Models¶

Biological Background¶

Protein Language Models¶

Embeddings for Proteins¶

Sequence Log-Probability as Fitness Proxy¶

ESM Model Evolution¶

Sources & license¶

`encode`¶

`predict`¶

`log_prob`¶