ESM Model Family Explained: ESM-2, ESM C, ESMFold2, and ESM3

ESM-2, ESM C, ESMFold, ESMFold2, and ESM3 share a name, but choosing between them starts with the output you need: numerical features, three-dimensional coordinates, or a new protein proposal.

This guide compares the main branches of the ESM family and gives a practical starting point for each. It assumes basic Python knowledge. Model availability and documentation were checked on September 21, 2026; the comparison summarizes official sources rather than a new benchmark run.

1. Compare the main models

ESM stands for Evolutionary Scale Modeling. A protein language model learns patterns in amino acid sequences, somewhat as a text model learns patterns in words. The shared name covers several architectures and tasks.

The task descriptions follow the ESM documentation, ESMC model card, ESMFold2 model card, and ESM3 model page. The suggested starting uses are my recommendations.

An embedding is a learned feature vector. A folding model produces coordinates. A generative model proposes missing sequence or structural information. These outputs require different evaluation methods, so there is no useful single ranking of the entire family.

2. ESM-2 versus ESM C: which representation model?

ESM-2: a convenient baseline

ESM-2 uses masked language modeling: hide amino acid tokens and learn to predict them from context. Its hidden states can become inputs to a downstream classifier or regression model. Extracting them does not, by itself, produce a structure or a measured functional property. The Transformers ESM documentation distinguishes the language model from its folding extension.

The family spans small checkpoints suitable for learning the workflow and much larger ones. Here are the published sizes from the original ESM repository:

For a first software check, I would use 8M. For an actual prediction project, select size by validation quality and resource use. A checkpoint that runs easily on a laptop is useful for debugging, but that does not make it the strongest biological baseline.

ESM C: the newer sequence representation branch

ESM C is short for ESM Cambrian; ESMC is another spelling used in code and model names. Its published scales are 300M, 600M, and 6B. Current Biohub model cards provide public checkpoints for all three, including biohub/ESMC-6B. Advice that the 6B model is available only through an API is therefore outdated for this release.

The Cambrian announcement reports improved efficiency and representation performance relative to ESM-2. For example, it compares ESM C 300M with ESM-2 650M on its reported evaluations. Treat that as evidence for trying ESM C, not a guarantee that it wins on every downstream dataset.

My comparison workflow would keep the data split and downstream learner fixed, then swap the embeddings. Record the checkpoint, layer, pooling method, runtime, and peak memory. Refit the downstream model after changing representations; matching tensor dimensions would not make two embedding spaces interchangeable.

3. ESMFold versus ESMFold2: which structure predictor?

The original ESMFold combines an ESM-2 stem with a structure-prediction head. It operates without an MSA search at inference time. An MSA, or multiple sequence alignment, supplies aligned related sequences; avoiding that search simplifies the original ESMFold workflow. See the official ESMFold overview.

ESMFold2 is an official model, with a different folding architecture built on ESMC representations and a diffusion-based structure head. The Transformers ESMFold2 documentation describes its iterative folding and coordinate-generation stages. It should not be confused with ESM-2 or the original esmfold_v1 checkpoint.

The Biohub model card documents broader inputs, including protein complexes, DNA, RNA, small molecules, and modified residues. The full model accepts optional MSA conditioning; ESMFold2-Fast does not. Support for an input type does not establish equal accuracy across every type of complex.

For a new structure project, I would compare ESMFold2-Fast and the full model on a small representative set before scaling up. Include MSA-search time when measuring end-to-end cost. Record folding loops, diffusion steps, sample count, and ranking method: changing these settings changes the experiment.

Biohub reports favorable results on selected FoldBench complex-prediction tasks in the ESMFold2 release material. Those claims depend on the targets, metrics, and inference settings. They do not mean every ESMFold2 prediction beats every alternative. A high confidence score also does not establish binding affinity or biological function.

4. ESM3: generation across sequence, structure, and function

ESM3 represents sequence, structure, and function information as separate token tracks. It can complete partial inputs through iterative unmasking. That makes it useful when the question is about generating a candidate under constraints, rather than simply extracting a feature vector. The ESM3 README explains this interface.

The documented family includes 1.4B, 7B, and 98B scales. The public small checkpoint, esm3-sm-open-v1, must be distinguished from the larger hosted models. Running the open checkpoint does not reproduce the capacity or every result of the 98B model. See the official model table.

ESM3 can generate structural information, but that does not make it a universal replacement for a dedicated folding model. I would choose it when multimodal conditioning is central to the task, then assess the proposals with independent evidence. Agreement between generation and refolding is useful as a consistency check, but is not an experimental measurement.

5. Other names worth recognizing

The older family includes ESM-1 and ESM-1b for sequence representations, ESM-1v for variant-effect prediction, MSA Transformer / ESM-MSA-1b for aligned sequences, and ESM-IF1 for inverse folding: proposing sequences from a supplied backbone. Their checkpoints and intended tasks are listed in the original model catalog.

The current ecosystem also includes ESMC sparse autoencoders (SAEs) and the ESM Atlas. SAEs expose sparse features from learned representations; the Atlas supports exploration of proteins and predicted structures. These serve interpretation and discovery roles alongside the models. See Biohub’s repository overview.

6. Choose a model by the next question you need to answer

For sequence prediction, I recommend splits that reflect deployment: if the test is supposed to represent unfamiliar families, closely related training sequences can make the result misleading. Keep feature selection and model tuning within the training process. For structure prediction, separate monomers from complexes and compare results within those categories.

The site’s antibody evaluation guide and CoFoldArena introduction discuss these evaluation choices in more detail.

7. Run a small ESM-2 example on CPU

This example shows the difference between one vector per residue and one pooled vector per sequence. It uses the 8M checkpoint, an artificial 20-residue input, and no API key. It does not compare model quality or run folding.

Create a separate environment:

mkdir esm-family-demo
cd esm-family-demo
python3 -m venv .venv
. .venv/bin/activate
python -m pip install torch 'transformers==4.57.6'

Save the following as esm2_shapes.py:

import argparse


def main():
    parser = argparse.ArgumentParser(description="Inspect ESM-2 residue and protein embeddings")
    parser.add_argument("--sequence", default="ACDEFGHIKLMNPQRSTVWY")
    args = parser.parse_args()
    sequence = args.sequence
    if not 1 <= len(sequence) <= 1022:
        parser.error("Use 1-1022 residues; this example never truncates")
    if set(sequence) - set("ACDEFGHIKLMNPQRSTVWY"):
        parser.error("Use the 20 standard uppercase amino acid letters")

    import torch
    from transformers import AutoTokenizer, EsmModel

    checkpoint = "facebook/esm2_t6_8M_UR50D"
    revision = "c731040fcd8d73dceaa04b0a8e6329b345b0f5df"
    tokenizer = AutoTokenizer.from_pretrained(checkpoint, revision=revision)
    model = EsmModel.from_pretrained(
        checkpoint, revision=revision, add_pooling_layer=False
    ).eval()
    batch = tokenizer(sequence, return_special_tokens_mask=True, return_tensors="pt")
    special = batch.pop("special_tokens_mask").bool()
    mask = batch["attention_mask"].bool() & ~special
    with torch.inference_mode():
        hidden = model(**batch).last_hidden_state
        residues = hidden[0, mask[0]]
        protein = residues.mean(dim=0)
    assert residues.shape == (len(sequence), model.config.hidden_size)
    assert torch.isfinite(protein).all()
    print("Residue embeddings:", tuple(residues.shape))
    print("Protein embedding:", tuple(protein.shape))
    print("Finite values:", bool(torch.isfinite(protein).all()))


if __name__ == "__main__":
    main()

Run it:

python esm2_shapes.py --help
python esm2_shapes.py
python -m pip freeze > requirements-tested.txt

Expected output:

Residue embeddings: (20, 320)
Protein embedding: (320,)
Finite values: True

The example was executed on CPU with Python 3.14.7, PyTorch 2.14.0, and Transformers 4.57.6. The output above matched. The model revision is pinned, and special tokens are removed before averaging. The artificial sequence checks the software path; no function or structure is claimed for it.

The first run needs internet access to download the model. Use --sequence with an amino acid string to change the input. The 1,022-residue cap is a conservative policy for this example. The script rejects nonstandard symbols and never silently truncates; verify that your source is protein data, since character validation alone cannot detect every mistaken DNA input.

For batching, saved vectors, and more detailed pooling checks, continue with the ESM-2 embeddings tutorial.

8. Installation and access: avoid mixing model generations

The original Meta repository uses the fair-esm distribution, while the current Biohub SDK uses esm. Both use the Python import name esm; I recommend separate environments. The Meta installation guide and Biohub guide document their respective packages.

The version pinned in the CPU example is for ESM-2. It is not an ESMFold2 installation recipe. Biohub currently documents both its SDK and newer Transformers integrations; checkpoint identifiers and inference methods differ. Follow one complete path rather than combining imports from different tutorials. The Transformers ESMFold2 page, for example, uses biohub/ESMFold2-hf.

For local weights, consult the exact checkpoint card. The current Biohub code license and ESM3-open card list MIT; older articles may describe earlier release terms. Hosted model availability and account access should be checked on the current platform rather than inferred from a local checkpoint.

Summary

Start with ESM-2 or ESM C for sequence features, ESMFold2 for a current folding workflow, and ESM3 when controllable multimodal generation is the main requirement. Keep ESMFold and the older specialist models when they match the baseline you need to reproduce. Choose the smallest experiment that can answer your question, then scale using evidence from your own evaluation.

Cover: AI-generated conceptual artwork illustrating sequence features, folding, and generation; not an experimental molecular structure.