Skip to main content
Docs

Search guides and API endpoints, for example “Idempotency-Key” or “submit job”.

    Tools · Computational Biology

    MPNN Sequence Design

    Design amino-acid sequences for fixed protein backbones with ProteinMPNN, LigandMPNN or SolubleMPNN, with chain, residue and amino-acid constraints and optional side-chain packing.

    Updated October 20, 2026

    On this page

    Prices, workflows, and method papersOpen in the app

    MPNN Sequence Design answers the question a backbone leaves open: which sequences would fold into it. You give it protein structures — a crystal structure, a prediction, or backbones from a generator — and it samples sequences for each one with a message-passing network trained for inverse folding. It is the sequence step in a design loop: generate backbones, design sequences for them, refold the sequences to check them.

    How it works

    Every backbone is held fixed and the network samples one residue at a time, conditioned on the structure around it. Three models are available. ProteinMPNN handles general protein backbones. LigandMPNN also reads the ligand, nucleotide and metal atoms in the file, so a binding site is designed with its partner in view. SolubleMPNN was trained only on soluble proteins. All three run from the LigandMPNN code and weights, which are MIT-licensed.

    The sampling temperature sets how conservative the sequences are: low values stay close to the most likely residue at each position, higher values give more diverse sets. A seed makes a run reproducible.

    Inputs

    • Backbones: protein structures as PDB or mmCIF, uploaded or bound from an upstream step. A structure from ESMFold2 binds to the structures input; designs from RFdiffusion3, BoltzGen or Boltz-2 bind to the backbones input. Several backbones go through one run, each with its own set of sequences.
    • Chains to design: designs only the chains you name and keeps the rest fixed as context.
    • Residues: either keep a list of residues fixed, or redesign only a list; names look like A12 or B42D (chain, number, insertion code) and follow the numbering in the file.
    • Amino-acid constraints: residues the designs may not use, and a per-residue bias that favors or disfavors others.
    • Symmetry and packing: tie the chains of a symmetric assembly together so they share a sequence, and optionally pack side chains onto every design.

    Chains and residues you name are checked against each structure before the job runs: the underlying tool silently ignores a residue it cannot find, which would return unconstrained designs, so the job fails and names the backbone instead.

    Outputs

    • sequences.fasta: one record per design, named after its backbone and sample number. The chains of a multi-chain backbone are joined with :.
    • scores.csv: per design, the overall confidence (the model's average confidence, from 0 to 1, in the sampled residues across the redesigned positions) and the sequence recovery (the fraction of redesigned residues identical to the input). For LigandMPNN there is also a ligand confidence, reported only when ligand atoms sit near the redesigned residues.
    • summary.json: the settings, the checkpoints used, and every design.
    • packed/: a structure with modelled side chains for each design, when packing is on.

    In a workflow, the sequences port feeds a sequence step such as ESMFold2 one design at a time, and the scores port carries the confidence and sequence_recovery metrics, so a filter step can keep the designs worth folding.

    Limits

    • Recovery is not quality. It shows how conservative a design is relative to the input sequence. A low recovery can be a good new design, and a high one can be a copy of the native sequence.
    • Confidence is not fitness. It ranks how typical a sequence looks for the backbone. Refold the sequences and compare the result with the backbone before trusting any of them.
    • A multi-chain design cannot bind into a single-chain folding step; fold its chains in a step that takes complexes.
    • Nucleic-acid chains and ligands are context only; they are never redesigned.
    • Packed side chains come from a learned model, not an energy minimization.

    RFdiffusion3 and BoltzGen generate the backbones, ESMFold2 and Boltz-2 fold the designed sequences back, and Binding ΔΔG uses ProteinMPNN to rank antibody variants rather than to generate sequences.

    Run it from the API

    Submit with Submit a job and the job_type below. Price it first with Estimate job reservation cost: submitting reserves that amount from your wallet, and the charge settles at the actual runtime.

    MPNN Sequence Design mpnn-design

    Job type
    mpnn-design
    Hardware
    t4 (default)l4a10l40sa100-40gba100-80gbh100h200b200
    Typical runtime
    15 min on Nvidia T4

    Payload

    Provide at least one of: structures, backbones.

    Payload fields
    FieldTypeDescription
    structures[]file_object[]

    Limits: min items 1, max items 50

    backbones[]file_object[]

    Limits: min items 1, max items 50

    model_typestring

    Default: "protein_mpnn"One of: "protein_mpnn", "ligand_mpnn", "soluble_mpnn"

    num_sequencesinteger

    Default: 8Limits: ≥ 1, ≤ 256

    temperaturenumber

    Default: 0.1Limits: ≥ 0.01, ≤ 1

    seedinteger

    Limits: ≥ 1, ≤ 2147483647

    chains_to_design[]string[]

    Limits: min items 1, max items 26

    fixed_residues[]string[]

    Limits: min items 1, max items 2000

    redesigned_residues[]string[]

    Limits: min items 1, max items 2000

    omit_aastring

    Limits: min length 1, max length 21, pattern ^[ACDEFGHIKLMNPQRSTVWYXacdefghiklmnpqrstvwyx]+$

    bias_aamap<string, number>
    homo_oligomerboolean

    Default: false

    pack_side_chainsboolean

    Default: false

    ligand_use_side_chain_contextboolean

    Default: false

    File fields take {"name": "x.pdb", "content_b64": "…"} or a stored artifact, {"$artifact": {"id": "art-…", "port": "…"}}. Files are up to 25 MiB each.

    Example

    from cognichem_client import CogniChem
    
    client = CogniChem.from_env()  # reads COGNICHEM_API_KEY
    payload = {
        "structures": [
            {
                "name": "backbone_a.pdb",
                "content_b64": "<file contents, base64>",
            },
        ],
        "model_type": "ligand_mpnn",
        "num_sequences": 3,
        "temperature": 0.1,
        "seed": 101,
    }
    
    estimate = client.jobs.estimate(job_type="mpnn-design", payload=payload, resource="t4")
    print(f"Reserves ${estimate.cost:.2f}")
    
    job = client.jobs.submit(
        job_name="my-mpnn-design-run",
        job_type="mpnn-design",
        payload=payload,
        resource="t4",
    )
    status = client.jobs.wait(job.process_id)
    if status.status == "completed":
        client.jobs.result(job.process_id, save_path=".")

    Sample data from the job catalog; long values are shortened here. Each job_name must be unique among your jobs.

    Workflow inputs

    • Structures (list) · optionalPDB, CIF
    • Protein structure (list) · optionalPDB, CIF

    Workflow outputs

    • ArchiveZIP
    • TableCSV
    • Protein sequencesFASTA