PoET is an MSA-conditioned, autoregressive protein language model that scores and encodes protein variants by modeling homologous families as sequences-of-sequences. The API exposes GPU-accelerated variant scoring (substitutions and indels) via conditional log-likelihoods, and MSA-aware sequence embeddings from aligned homolog sets (up to 1024 residues, 4096 sequences). Typical uses include zero-shot fitness prediction for deep mutational scanning libraries, prioritizing enzyme or antibody variants, and constructing evolutionary-context features for downstream ML models.

Predict

Run the predict action for PoET.

python 
from biolmai import BioLM
response = BioLM(
    entity="poet",
    action="predict",
    params={'ensemble': True, 'seed': 188257, 'batch_size': 8},
    items=[{'sequences': ['MKTAYIAKQRQISFVKSHFSRQ', 'MKTAYIAKQRQISFVKSHFSRQ'],
      'msa': ['MKTAYIAKQRQISFVKSHFSRQ',
              'MKTA--AKQRQISFVKSHFSRQ',
              'MKTAYIAK-RQISFVKSHFSRQ',
              'MKTAYIAKQRQ-SFVKSHFSRQ']}]
)
print(response)
bash 
curl -X POST https://biolm.ai/api/v3/poet/predict/ \
  -H "Authorization: Token YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "items": [
    {
      "sequences": [
        "MKTAYIAKQRQISFVKSHFSRQ",
        "MKTAYIAKQRQISFVKSHFSRQ"
      ],
      "msa": [
        "MKTAYIAKQRQISFVKSHFSRQ",
        "MKTA--AKQRQISFVKSHFSRQ",
        "MKTAYIAK-RQISFVKSHFSRQ",
        "MKTAYIAKQRQ-SFVKSHFSRQ"
      ]
    }
  ],
  "params": {
    "ensemble": true,
    "seed": 188257,
    "batch_size": 8
  }
}'
python 
import requests

url = "https://biolm.ai/api/v3/poet/predict/"
headers = {
    "Authorization": "Token YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
      "items": [
        {
          "sequences": [
            "MKTAYIAKQRQISFVKSHFSRQ",
            "MKTAYIAKQRQISFVKSHFSRQ"
          ],
          "msa": [
            "MKTAYIAKQRQISFVKSHFSRQ",
            "MKTA--AKQRQISFVKSHFSRQ",
            "MKTAYIAK-RQISFVKSHFSRQ",
            "MKTAYIAKQRQ-SFVKSHFSRQ"
          ]
        }
      ],
      "params": {
        "ensemble": true,
        "seed": 188257,
        "batch_size": 8
      }
    }

response = requests.post(url, headers=headers, json=payload)
print(response.json())
r 
library(httr)

url <- "https://biolm.ai/api/v3/poet/predict/"
headers <- c("Authorization" = "Token YOUR_API_KEY", "Content-Type" = "application/json")
body <- list(
  items = list(
    list(
      sequences = list(
        "MKTAYIAKQRQISFVKSHFSRQ",
        "MKTAYIAKQRQISFVKSHFSRQ"
      ),
      msa = list(
        "MKTAYIAKQRQISFVKSHFSRQ",
        "MKTA--AKQRQISFVKSHFSRQ",
        "MKTAYIAK-RQISFVKSHFSRQ",
        "MKTAYIAKQRQ-SFVKSHFSRQ"
      )
    )
  ),
  params = list(
    ensemble = TRUE,
    seed = 188257,
    batch_size = 8
  )
)

res <- POST(url, add_headers(.headers = headers), body = body, encode = "json")
print(content(res))
POST /api/v3/poet/predict/

Predict endpoint for PoET.

Request Headers:

Request

  • params (object, optional) — Configuration parameters:

    • ensemble (boolean, default: True) — Enable 15-member ensemble scoring

    • seed (integer, default: 188257) — Random seed for MSA subsampling

    • batch_size (integer, range: 1–64, default: 8) — Batch size for variant scoring

  • items (array of objects, min items: 1, max items: 1) — Input data items:

    • sequences (array of strings, min items: 1, max items: 1000, each max length: 1024, required) — Unaligned variant protein sequences as amino acid strings

    • msa (array of strings, min items: 2, max items: 4096, all same length, each max length: 1024, required) — Multiple-sequence alignment of homologous sequences with gaps allowed (- or .), all sequences aligned to the same length

Example request:

http 
POST /api/v3/poet/predict/ HTTP/1.1
Host: biolm.ai
Authorization: Token YOUR_API_KEY
Content-Type: application/json

      {
  "items": [
    {
      "sequences": [
        "MKTAYIAKQRQISFVKSHFSRQ",
        "MKTAYIAKQRQISFVKSHFSRQ"
      ],
      "msa": [
        "MKTAYIAKQRQISFVKSHFSRQ",
        "MKTA--AKQRQISFVKSHFSRQ",
        "MKTAYIAK-RQISFVKSHFSRQ",
        "MKTAYIAKQRQ-SFVKSHFSRQ"
      ]
    }
  ],
  "params": {
    "ensemble": true,
    "seed": 188257,
    "batch_size": 8
  }
}
Status Codes:

Response

  • results (array of objects) — One result per input item, in the order requested:

    • scores (array of objects) — Per-sequence fitness scores:

      • sequence_index (int, >= 0) — Zero-based index of the variant sequence within the request item’s sequences array

      • fitness_score (float) — Variant fitness score for the corresponding sequence (unbounded real value)

Example response:

http 
HTTP/1.1 200 OK
Content-Type: application/json

      {
  "results": [
    {
      "scores": [
        {
          "sequence_index": 0,
          "fitness_score": -48.53720474243164
        },
        {
          "sequence_index": 1,
          "fitness_score": -48.53720474243164
        }
      ]
    }
  ]
}

Encode

Run the encode action for PoET.

python 
from biolmai import BioLM
response = BioLM(
    entity="poet",
    action="encode",
    params={'ensemble': False, 'seed': 188257, 'batch_size': 8},
    items=[{'sequence': 'MKTVA',
      'msa': ['MKTVA',
              'MKTIA',
              'MKTLA',
              'MKSVA',
              'MRTVA',
              'MKTVA',
              'MKTVA',
              'MKTAA',
              'MKTVA',
              'MNTVA']}]
)
print(response)
bash 
curl -X POST https://biolm.ai/api/v3/poet/encode/ \
  -H "Authorization: Token YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "params": {
    "ensemble": false,
    "seed": 188257,
    "batch_size": 8
  },
  "items": [
    {
      "sequence": "MKTVA",
      "msa": [
        "MKTVA",
        "MKTIA",
        "MKTLA",
        "MKSVA",
        "MRTVA",
        "MKTVA",
        "MKTVA",
        "MKTAA",
        "MKTVA",
        "MNTVA"
      ]
    }
  ]
}'
python 
import requests

url = "https://biolm.ai/api/v3/poet/encode/"
headers = {
    "Authorization": "Token YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
      "params": {
        "ensemble": false,
        "seed": 188257,
        "batch_size": 8
      },
      "items": [
        {
          "sequence": "MKTVA",
          "msa": [
            "MKTVA",
            "MKTIA",
            "MKTLA",
            "MKSVA",
            "MRTVA",
            "MKTVA",
            "MKTVA",
            "MKTAA",
            "MKTVA",
            "MNTVA"
          ]
        }
      ]
    }

response = requests.post(url, headers=headers, json=payload)
print(response.json())
r 
library(httr)

url <- "https://biolm.ai/api/v3/poet/encode/"
headers <- c("Authorization" = "Token YOUR_API_KEY", "Content-Type" = "application/json")
body <- list(
  params = list(
    ensemble = FALSE,
    seed = 188257,
    batch_size = 8
  ),
  items = list(
    list(
      sequence = "MKTVA",
      msa = list(
        "MKTVA",
        "MKTIA",
        "MKTLA",
        "MKSVA",
        "MRTVA",
        "MKTVA",
        "MKTVA",
        "MKTAA",
        "MKTVA",
        "MNTVA"
      )
    )
  )
)

res <- POST(url, add_headers(.headers = headers), body = body, encode = "json")
print(content(res))
POST /api/v3/poet/encode/

Encode endpoint for PoET.

Request Headers:

Request

  • params (object, optional) — Configuration parameters:

    • ensemble (boolean, default: True) — Use full 15-member ensemble for scoring/encoding

    • seed (integer, default: 188257) — Random seed for MSA subsampling reproducibility

    • batch_size (integer, range: 1-64, default: 8) — Batch size for processing items

  • items (array of objects, min items: 1, max items: 1) — Input sequence and MSA context:

    • sequence (string, min length: 1, max length: 1024, required) — Single unaligned protein sequence to encode using the extended amino acid alphabet

    • msa (array of strings, min items: 2, max items: 4096, required) — Multiple sequence alignment of homologs as aligned sequences of equal length, first sequence is the wildtype/query and may include gap characters

Example request:

http 
POST /api/v3/poet/encode/ HTTP/1.1
Host: biolm.ai
Authorization: Token YOUR_API_KEY
Content-Type: application/json

      {
  "params": {
    "ensemble": false,
    "seed": 188257,
    "batch_size": 8
  },
  "items": [
    {
      "sequence": "MKTVA",
      "msa": [
        "MKTVA",
        "MKTIA",
        "MKTLA",
        "MKSVA",
        "MRTVA",
        "MKTVA",
        "MKTVA",
        "MKTAA",
        "MKTVA",
        "MNTVA"
      ]
    }
  ]
}
Status Codes:

Response

  • results (array of objects) — One result per input item, in the order requested:

    • sequence_index (int) — Zero-based index of the encoded sequence within the request items[0].sequence

    • embedding (array of floats) — Fixed-length PoET embedding vector for the sequence - Size: model-dependent 1D array - Values: real-valued, unbounded in practice (no fixed range) - Example: [-0.4529, -0.0774, -0.2307, -0.3583, 0.0535, ... (truncated for documentation)]

Example response:

http 
HTTP/1.1 200 OK
Content-Type: application/json

      {
  "results": [
    {
      "sequence_index": 0,
      "embedding": [
        -0.45292970538139343,
        -0.07740936428308487,
        "... (truncated for documentation)"
      ]
    }
  ]
}

Performance

  • Predictive accuracy on ProteinGym deep mutational scans - Substitutions (Spearman ρ between predicted score and experimental fitness, all datasets): PoET ensemble ≈0.48 vs ProGen2 ensemble ≈0.41, ESM-1v ensemble ≈0.40, GEMME ≈0.46, MSA Transformer ≈0.42 - Indels: PoET ensemble ≈0.51 vs Tranception L ≈0.46; GEMME, ESM-1v, MSA Transformer, and EVE cannot reliably score general insertions/deletions across ProteinGym - Across MSA depths, PoET improves substitution-effect prediction over single-sequence language models at low depth and matches or exceeds alignment-based models at medium/high depth, while uniquely retaining robust indel support

  • Comparative behavior vs other BioLM fitness models - Versus single-sequence LMs (ESM-2/ESM-1v, ProGen2): PoET uses homologous sequence context to improve ranking of variants in a given family, especially for multi-mutation variants and indels; single-sequence LMs remain preferable for very high-throughput, approximate triage when no MSA-quality homologs are available - Versus MSA-aware models (MSA Transformer, GEMME, EVE): PoET avoids hard alignment column constraints, maintains or slightly improves accuracy on substitutions, and provides native scoring of both deletions and novel insertions that are difficult or impossible to handle consistently with alignment-based or VAE-based approaches - Versus TranceptEVE-style hybrids: PoET achieves similar substitution accuracy without any per-target VAE training; TranceptEVE can slightly exceed PoET when available but at substantially higher per-target preprocessing cost

  • Indel-aware and MSA-depth robustness characteristics - PoET’s sequence-of-sequences autoregressive architecture models insertions and deletions directly in sequence space, enabling scoring of loop trims/expansions, domain insertions, and CDR length variants without requiring the indel to appear in the reference MSA - Performance remains strong from shallow MSAs (Neff/L < 1) through very deep alignments, mitigating the sharp degradation seen with many classical alignment-based models on families with few homologs - Empirically robust across taxonomic groups (human and other eukaryotic, prokaryotic, viral proteins), with variant–fitness correlations that match or exceed other BioLM fitness models in each category

  • Deployment, scaling, and relative throughput - PoET is a ~201M-parameter transformer with tiered (within/between sequence) attention optimized for GPU inference on attention-heavy workloads; it generalizes to deeper MSAs than seen during training without the context-length degradation typical of standard RoPE-only transformers - Inference is slower per query than single-sequence BioLM models because it embeds MSA context and may run a 15-member ensemble, but remains substantially cheaper per variant than structure prediction models (e.g., AlphaFold2-like pipelines) - When many variants share the same MSA, PoET amortizes MSA processing across the batch so additional variants incur relatively small incremental cost, making it suitable for accurate ranking of tens to hundreds of thousands of variants per protein in realistic GPU-backed workflows

Applications

  • Zero-shot prioritization of protein variants in engineering campaigns using MSA-conditioned fitness scoring (substitutions and indels), enabling teams to rank thousands of candidate mutations for an existing protein (e.g., enzyme variants for higher activity or stability) before synthesis; PoET’s autoregressive, family-aware log-likelihoods highlight variants that are evolutionarily plausible in the context of the homologous family, improving hit rates and reducing wet-lab screening burden compared to single-sequence models that cannot use MSA information

  • Indel-aware loop and linker engineering for protein therapeutics and industrial enzymes by scoring insertions and deletions in flexible regions (e.g., surface loops near an active site, inter-domain linkers in fusion proteins), where traditional MSA-only or VAE-style models cannot robustly handle length changes; PoET’s ability to assign probabilities to sequences with different lengths within the same family lets teams explore length and composition changes while avoiding clearly disruptive designs, especially useful when redesigning catalytic loops, signal peptides, or secretion tags

  • Family-specific library design for directed evolution or semi-rational design by generating and/or filtering variant libraries within a defined protein family (e.g., PLP-dependent enzymes, transporters, receptor domains) using PoET’s evolutionary transformer as a retrieval-augmented scorer or generator; by conditioning on curated homolog sets (for example, thermostable homologs or homologs from specific taxa), teams can bias libraries toward regions of sequence space that respect family-wide constraints, increasing the fraction of folded and functional variants while still exploring novel sequence combinations not present in natural databases

  • Risk assessment and triage of manufacturing- or developability-relevant mutations in biologics and enzyme production (e.g., back-translation from codon optimization, process-driven sequence changes, tag additions) by comparing PoET scores for proposed variants vs. the wildtype baseline within the same MSA; because PoET has been validated on deep mutational scanning data across diverse proteins, its log-likelihood deltas can flag variants that are likely to disrupt folding or core function, helping process and CMC teams filter out higher-risk sequence changes early, though it should be combined with stability, aggregation, and immunogenicity tools for full developability assessment

  • Function-focused reweighting within a protein family by conditioning PoET on only those homologs known or strongly predicted to share a specific property (e.g., chorismate mutases active in a particular host, enzymes from thermophiles for high-temperature processes), so that fitness scores and generated variants reflect that subset’s constraints rather than the entire family; this “prompt-like” use of the model allows commercial teams to bias designs toward application-relevant niches while still relying on learned evolutionary structure, but depends on having a reasonably sized, accurately labeled or well-filtered subset of homologs and is less effective when only a few sequences are available

Limitations

  • Sequence and MSA size constraints: All protein sequences in sequences or sequence must be amino acid strings of length 1..1024 (max_sequence_len = 1024). All aligned MSA entries in msa must have identical length, use only valid MSA characters (amino acids plus gaps '-'/'.'), and each entry must be <= 1024 characters. Requests with longer sequences, empty MSAs, or inconsistent MSA column lengths are rejected.

  • MSA requirements and depth limits: PoET is an MSA-conditioned model and cannot score or encode without homologous context. The msa field must contain at least 2 and at most 4096 aligned sequences (max_msa_depth = 4096). Very shallow MSAs (near the minimum) often yield noisy or weakly informative fitness_score values, and truly orphan proteins with no detectable homologs cannot be evaluated. The first MSA sequence should be the wildtype or query sequence used as reference.

  • Ensemble vs. throughput trade-off: The optional PoETRequestParams control accuracy vs. speed. With ensemble = True (default), PoET uses a 15-configuration ensemble with stochastic MSA subsampling, which improves robustness but is slower and more GPU-intensive. Setting ensemble = False uses a single configuration and is much faster, but can be less stable on difficult or low-diversity MSAs. The batch_size parameter (default 8, allowed 1..64) affects GPU memory use; for long sequences, deep MSAs, or many variants, you may need to lower batch_size to avoid out-of-memory errors.

  • Scope of supported mutations and interpretation of scores: Any amino acid variant sequence in sequences can be scored as long as it is a full-length, unaligned sequence of the same protein (substitutions, insertions, and deletions relative to the wildtype in the msa are all allowed up to length 1024). PoET does not support mixing unrelated domains or arbitrary chimeras as if they belonged to one family. The returned fitness_score is a log-likelihood-based, relative evolutionary fitness proxy, not a calibrated value for a specific assay (e.g. binding affinity, expression, or stability). It is most reliable for ranking variants of the same protein under one experimental context and should be used with appropriate experimental or orthogonal model validation.

  • Cases where PoET is not optimal: When you cannot build a meaningful MSA (e.g. very short peptides, highly disordered regions, chimeric constructs, or proteins with no or almost no detectable homologs), PoET is not suitable and single-sequence or simpler heuristic models are usually preferable. For extremely high-throughput, low-latency scanning of millions of variants where approximate ranking is sufficient, faster single-sequence or distilled models are typically more appropriate than PoET’s MSA-conditioned ensemble.

  • Model and family coverage limitations: PoET was trained on large sets of natural protein families and is tuned for typical enzymes and globular proteins. Performance may degrade for very long, multi-domain proteins truncated to the 1024-residue limit, MSAs with very low diversity or heavy sampling bias (e.g. near-identical sequences from one strain), or synthetic/de novo families whose statistics differ strongly from natural proteins. In such cases, fitness_score may correlate poorly with experimental outcomes, and results should be interpreted cautiously and, where possible, combined with other models or structural/functional data.

How We Use It

PoET enables zero-shot, MSA-aware scoring of substitutions and indels that plugs directly into BioLM’s protein design and optimization workflows, giving teams a standardized way to prioritize variants before committing to synthesis, assay, or scale-up. In practice, we run PoET alongside generative sequence models, structure predictors, and stability/ADMET predictors to rank or filter large in silico libraries, focus higher-fidelity modelling (e.g. 3D, docking, biophysics) on evolutionarily plausible candidates, and steer multi-round design–build–test–learn cycles for enzymes, antibodies, and other proteins. Exposed via scalable, consistent APIs, PoET integrates into automated pipelines from MSA construction through scoring to downstream QC, while wet-lab teams gain clear, fitness-style scores that de-risk experimental campaigns and reduce the number of variants that must be synthesized and tested.

  • We combine PoET scores with structure-based metrics and biophysical predictors to triage libraries, typically using PoET as an evolution-informed gate before more expensive modelling or lab work.

  • In iterative engineering programs, PoET scores on new sequence data from successive experimental rounds feed back into our ML pipelines to refine candidate selection and accelerate convergence on variants that meet target functional, stability, and manufacturability specifications.

References