AlphaFold-Multimer for Homomeric Complexes

By Dr. Zubair Khalid, DVM, MS, PhD · 2026-11-11

Homomeric complexes are assemblies of two or more copies of the same protein chain. They include transcription factor dimers, enzyme tetramers, viral capsid building blocks, and most of the symmetric barrels and cages annotated in the Protein Data Bank. Predicting them from sequence is one of the highest-value uses of AlphaFold-Multimer, the multi-chain extension of AlphaFold2, because a correct oligomer model exposes the inter-chain interface that single-chain models cannot show.

This AlphaFold tutorial walks through the full homomer workflow. By the end of the article you will be able to encode a candidate stoichiometry in a FASTA file, run AlphaFold-Multimer homomer prediction from the command line with ColabFold, read every confidence number the model emits, compare dimer, trimer, and tetramer hypotheses in a single batch, and apply rescuing workflows when the direct prediction fails.

On hand you need the target sequence in FASTA format, a Linux or macOS terminal, and either a local NVIDIA GPU or a free Google Colab session. The hosted AlphaFold server covers quick single predictions with nothing installed. Optional but useful are a PyMOL or ChimeraX installation for visual inspection and a literature note on the suspected oligomer state.

How AlphaFold-Multimer Handles Identical Chains

AlphaFold2 predicts a single chain by combining evolutionary information from a multiple sequence alignment (MSA, the column-aligned set of homologous sequences) with pairwise geometric reasoning inside a deep attention architecture. AlphaFold-Multimer, usually abbreviated AF-Multimer, extends that pipeline to multiple chains. It was trained on multi-chain entries from the Protein Data Bank, encodes each chain with reference frames relative to the whole assembly, and pairs MSAs across chains so that co-evolution between different proteins can inform the interface.

Running AlphaFold-Multimer for homomeric complexes differs from plain monomer folding in three specific ways. First, stoichiometry is a user decision. The network folds whatever chains you give it, so a dimeric protein handed three copies returns a trimer-shaped model, sometimes with high confidence. Second, all chains share one sequence, so the MSA is computed once and reused for every copy, and there is no paralog-pairing signal of the kind that helps heteromeric interfaces. Third, real homomers almost always assemble with cyclic or dihedral symmetry, while AF-Multimer has no explicit symmetry constraint. It usually converges to near-symmetric arrangements, but the copies should always be superposed as a sanity check. Historically this is the same symmetry-sampling problem that made homomers a hard class for classical docking, which is worth remembering when a prediction looks effortless.

Calibrate expectations before running anything. One widely cited benchmark analysis puts AF-Multimer's rate of accurate complex predictions at up to 43 percent of cases, which is transformative by historical docking standards and still far from solved [1]. Systematic evaluations that score AF-Multimer among eleven classical and deep-learning docking methods show the field moving fast, with AlphaFold 3 reaching a 77.98 percent top-5 success rate against apo (unbound) structures on a modern docking benchmark while the best classical server managed 12.84 percent on the same test, even though that server reached 85.24 percent when given holo (bound) structures [2]. Pre-training research that manufactures pseudo-dimers from monomeric proteins has already beaten both AF-Multimer and AlphaFold 3 on several dimer targets from CASP15, the community-wide structure-prediction assessment, a sign that the scarcity of complex training structures rather than the architecture alone currently limits accuracy [3].

Choose Your Route: the AlphaFold Server or a Local Install

The AlphaFold server at alphafoldserver.com is Google DeepMind's hosted interface to AlphaFold 3, the successor system that added nucleic acids, ligands, and modified residues to the co-folding stack. You paste sequences, add the same chain once per copy of your homomer, and receive ranked models with confidence annotations. No installation, no GPU, no MSA configuration. The tradeoffs are fixed: you cannot choose the number of recycling passes, you cannot sweep random seeds, job length and chain-count limits apply, and the terms of use restrict some commercial applications.

Independent evidence supports the server with caveats. In an evaluation of the AlphaFold Server alongside five template-free docking web servers on 235 protein-RNA complexes, AlphaFold 3 reached an 87.0 percent success rate among its top five predictions and beat every docking server, yet it failed nine cases that the docking methods solved [4]. The lesson transfers directly to homomers. The server is the fastest route to a first look, and a local installation remains necessary for stoichiometry sweeps, seed replication, recycling experiments, and batch processing.

ColabFold is the standard local wrapper for AF-Multimer. It downloads the network weights, calls the MMseqs2 web service for MSAs by default so you avoid hosting terabytes of sequence databases, and exposes every parameter that matters through one command, colabfold_batch. A free Google Colab notebook runs the same stack on a borrowed GPU if you have no local hardware.

Step-by-Step: AlphaFold-Multimer Homomer Prediction with ColabFold

Step 1: Fix the Sequence and the Candidate Stoichiometries

Pull the canonical sequence from UniProt and remove affinity tags, cloning artifacts, and expression constructs. Then collect every hint about the native oligomer state: PDB entries of homologs, UniProt subunit annotations, size-exclusion chromatography with multi-angle light scattering, native mass spectrometry, and mutagenesis papers that map interfaces. Write down two or three candidate stoichiometries, for example dimer and tetramer, because the whole point of the batch workflow below is to test them head to head.

Size the job before running. AF-Multimer memory and runtime scale with the total residue count across all chains, so a 140-residue chain folded as a trimer behaves like a 420-residue single-chain prediction. A tetramer of the same chain behaves like a 560-residue monomer. If your largest candidate exceeds what your GPU tolerates, start with the smaller oligomers and treat the biggest one as a separate, carefully budgeted run.

Step 2: Build the Multi-Chain FASTA

AF-Multimer reads one FASTA record per chain. For a homotrimer the same sequence appears three times. Save a single copy as chain.fasta, then generate the oligomer files with a short script:

import sys

n = int(sys.argv[3])
lines = [line.strip() for line in open("chain.fasta") if not line.startswith(">")]
seq = "".join(lines)
with open(f"homo_{n}mer.fasta", "w") as out:
    out.write(f">homo_{n}mer\n")
    for _ in range(n):
        out.write(seq + "\n")
print(f"wrote homo_{n}mer.fasta with {n} identical chains")

Running python make_oligomer_fasta.py 3 produces:

>homo_3mer
MTEITAKLEREQAT...
MTEITAKLEREQAT...
MTEITAKLEREQAT...

ColabFold also accepts a single-line query with chains separated by colons, for example SEQ1:SEQ1:SEQ1, and it detects identical sequences automatically, computing the MSA once and sharing it across copies. The repeated-record format is the safer habit because it makes the intended stoichiometry visible in the file itself.

Step 3: Install ColabFold

With conda available:

conda create -n af python=3.11 -y
conda activate af
pip install "colabfold[alphafold-minus-cuda]"

The alphafold-minus-cuda extra installs everything except the CUDA build of JAX, which you then match to your driver version following the current ColabFold README. On a machine without a GPU, skip that step and use the Colab notebook instead. Confirm the install:

colabfold_batch --help

You should see the full flag list covering model type, model count, recycling, seeds, MSA mode, and relaxation.

Step 4: Run the Prediction

Run the homotrimer:

colabfold_batch \
  --model-type alphafold2_multimer_v3 \
  --num-models 5 \
  --num-recycle 12 \
  --num-seeds 4 \
  --msa-mode mmseqs2_uniref_env \
  --amber \
  homo_3mer.fasta out_3mer

Each flag controls one decision. The model type selects the latest AF-Multimer weights. Five model presets give architecturally diverse predictions. Twelve recycling passes give the network far more refinement iterations than the default three, which matters for large assemblies. Four seeds mean four independent stochastic runs per model preset, twenty predictions in total, so that one unlucky initialization cannot masquerade as the answer. The MSA mode uses the default UniRef plus environmental metagenomic search. Amber relaxation removes clashes from the final coordinates.

Expect minutes for a small dimer on a modern GPU and hours for a large oligomer with this many recycles and seeds. Progress prints once per model and seed.

When the run finishes, the output directory looks like this:

out_3mer/
  homo_3mer.a3m
  homo_3mer_unrelaxed_rank_001_alphafold2_multimer_v3_model_1_seed_000.pdb
  homo_3mer_relaxed_rank_001_alphafold2_multimer_v3_model_1_seed_000.pdb
  homo_3mer_scores_rank_001_alphafold2_multimer_v3_model_1_seed_000.json
  homo_3mer*pae*.png
  ... (four more model presets, four seeds each)

Rank 001 is the model with the best combined confidence score. The JSON file beside each PDB holds the numbers you will actually use.

If something breaks, the table below covers the failures seen most often in homomer runs.

Step 5: Read the Scores

Four numbers govern interpretation. pLDDT is a per-residue confidence from 0 to 100, stored in the B-factor column of the PDB, and it describes how well each residue's local structure is determined. pTM is a predicted TM-score for the whole assembly, from 0 to 1. ipTM, the interface predicted TM-score, measures the same quantity restricted to residues that sit between different chains, and it is the single most informative number for oligomer work. The predicted aligned error (PAE) matrix gives expected positional error in angstroms for every residue pair, and the off-diagonal blocks between different chains are where interface uncertainty hides. ColabFold ranks models by a weighted sum, 0.8 times ipTM plus 0.2 times pTM.

Print a ranked table:

import glob, json

rows = []
for path in sorted(glob.glob("out_3mer/*_scores_rank_*.json")):
    with open(path) as handle:
        d = json.load(handle)
    label = path.split("/")[-1].replace("homo_3mer_scores_", "").replace(".json", "")
    rows.append((label, d["iptm"], d["ptm"], d["ranking_metric"]))

rows.sort(key=lambda row: -row[1])
for label, iptm, ptm, metric in rows:
    print(f"{label:<60}{iptm:>7.3f}{ptm:>7.3f}{metric:>7.3f}")

Illustrative output, your numbers will differ:

rank_001_alphafold2_multimer_v3_model_2_seed_000              0.872  0.914  0.880
rank_002_alphafold2_multimer_v3_model_4_seed_001              0.845  0.902  0.856
rank_003_alphafold2_multimer_v3_model_2_seed_002              0.838  0.895  0.849
rank_004_alphafold2_multimer_v3_model_1_seed_000              0.794  0.881  0.811

A working rule of thumb from the AF-Multimer developers treats ipTM above roughly 0.8 as likely correct and below about 0.6 as likely wrong, with the middle band demanding case-by-case scrutiny. Read the rule together with the PAE matrix. A model can carry a respectable ipTM while one chain sits at 15 angstroms of expected error relative to the rest, which means the interface pose is a guess. Conversely, a trimer with two crisp inter-chain blocks and one pale block is telling you exactly which interface deserves experimental attention.

Step 6: Compare Stoichiometries

Generate the candidate files and run everything in one batch:

mkdir -p fastas outs
for n in 2 3 4 5
do
  python make_oligomer_fasta.py ${n}
  mv homo_${n}mer.fasta fastas/
done

colabfold_batch \
  --model-type alphafold2_multimer_v3 \
  --num-models 5 \
  --num-recycle 12 \
  --num-seeds 4 \
  fastas outs

Then take the best ranking metric per oligomer:

import glob, json

best = {}
for path in glob.glob("outs/*/*_scores_rank_*.json"):
    oligomer = path.split("/")[3]
    with open(path) as handle:
        d = json.load(handle)
    score = d["ranking_metric"]
    if oligomer not in best or score > best[oligomer]:
        best[oligomer] = score

for oligomer in sorted(best, key=lambda name: int(name.split("_")[3].replace("mer", ""))):
    print(f"{oligomer}\t{best[oligomer]:.3f}")

Illustrative output:

homo_2mer  0.74
homo_3mer  0.88
homo_4mer  0.61
homo_5mer  0.50

In this example the trimer wins by a wide margin and the tetramer trail-off suggests the interface cannot absorb a fourth copy. Interpret with care. A large gap between the best and runner-up stoichiometry is meaningful, a small gap is not, and a high score for a stoichiometry that contradicts years of biophysics usually means the network found a plausible-looking alternative contact rather than the biological one. Treat the sweep as a hypothesis generator that must agree with experimental evidence, not as a verdict.

Step 7: Verify Chains, Relax, and Inspect

Confirm the stoichiometry actually landed in the coordinates. Count chains by the chain identifier column of the PDB:

grep "^ATOM" out_3mer/homo_3mer_relaxed_rank_001*.pdb | cut -c22 | sort | uniq -c

Expected output for a clean trimer:

   1523 A
   1518 B
   1509 C

Three chains with comparable residue counts is what you want. One chain means the input was wrong, and wildly unequal counts mean a parsing problem.

Open the top models in PyMOL or ChimeraX and check three things. Superpose the chains on one another, since a genuine homomer should show internally consistent copies even though AF-Multimer never enforces symmetry. Examine the interface for a mix of hydrophobic cores and polar contacts rather than a single salt bridge holding two chains together. Finally, open the PAE heat map image next to each model and confirm the inter-chain blocks are as dark as the intra-chain diagonal. Measure on the relaxed coordinates, not the unrelaxed ones.

Practical Tips for Better Homomer Models

Sweep seeds before believing any single model. Agreement across four or more seeds on the same interface is the cheapest reliability signal available, and disagreement is diagnostic in its own right, telling you the assembly has multiple low-energy packing options the network cannot rank.

Push recycling for big assemblies. Small dimers converge with few passes, while assemblies of a thousand or more total residues often keep improving through 12 to 24 recycles. Watch the per-recycle confidence printout for a plateau instead of assuming the default converged.

Test MSA dependence deliberately. Rerun the winning stoichiometry with a shallow alignment using the max-MSA cap, for example 128:256. If the interface geometry survives a starved MSA, the prediction rests on more than one deep-alignment interpretation.

Use templates with intent. A template from a homologous subunit can stabilize the fold of each chain, but a template of a whole oligomer can drag the interface toward a distant evolutionary arrangement. Compare template and no-template runs whenever a close homolog exists.

Check for more than one interface type. Many homomers close a ring using two chemically distinct interfaces, and AF-Multimer sometimes samples only one of them. Verify that the predicted assembly buries a consistent contact pattern on every side of the ring or filament.

For assemblies beyond your memory budget, predict a dimer, extract the interface, and build the full ring or cage by applying the expected symmetry, then confirm that symmetry-expanded copies do not clash and that the duplicated interface matches the predicted contact pattern.

Keep a run manifest. Record the ColabFold version, model type, flags, seeds, and the date of the MSA search, because the databases behind the MMseqs2 web service change over time and yesterday's best model may not reproduce exactly.

Compare model generations when the stakes are high. Running the same query under the multimer v2 and v3 weights costs little and exposes predictions that depend on one training snapshot.

Judging Model Confidence the Right Way

Confidence numbers are model self-assessments, not measurements. Three practices keep them honest.

First, read ipTM and the inter-chain PAE together, never ipTM alone. The interface TM-score compresses the whole contact surface into one scalar, while the PAE matrix shows where relative placement is uncertain. A trimer with two confident interfaces and one diffuse third interface is a different biological claim from a uniformly confident trimer, and the scalar cannot tell them apart.

Second, expect the self-assessment to be imperfect at ranking. CAPRI, the community-wide experiment that blind-assesses complex modeling, has surfaced repeated cases where AlphaFold confidence metrics mislead model selection, including near-native models that ranked low within a submission set [5]. Dedicated interface scorers now beat the model's own numbers on benchmarks, as shown by EquiRank, an equivariant graph neural network scorer that outperformed the AF-Multimer self-assessment repurposed for complex scoring [6], and learned scoring functions such as EuDockScore exist specifically as a final filtering layer for generated interfaces [7]. Rescoring a top-20 pool is cheap insurance.

Third, match the confidence question to the biology. pLDDT doubles as a flexibility readout, and docking work has repurposed it for exactly that, estimating which regions of a predicted structure can move during binding [1]. A homomer interface lined with low-pLDDT loops deserves a dynamic interpretation rather than a single-frame report. Static co-folding outputs are snapshots, and a benchmark that ran molecular dynamics on more than 200 protein-protein complexes from the docking benchmark, three 100-nanosecond replicas per complex, exists precisely because interface flexibility is functionally important and invisible to any single predicted coordinate set [8].

Anchor the model in independent evidence whenever it exists: measured oligomer state in solution, interface mutagenesis, cross-linking distance restraints, and conservation patterns mapped onto the interface. A model that agrees with none of them is a hypothesis to test, not a result to report.

Hybrid Workflows When AlphaFold-Multimer Alone Falls Short

Escalate when seeds disagree, ipTM stalls in the ambiguous band, PAE blocks stay diffuse, or prior biology demands a conformational change that co-folding rarely delivers.

Replica-exchange docking seeded by AlphaFold is the most direct rescue. AlphaRED uses AF predictions as templates for a physics-based replica exchange protocol and converted 97 AF failures from a standard docking benchmark into a pipeline that reaches CAPRI-acceptable or better models for 63 percent of targets, including a 43 percent success rate on an antibody-antigen subset where AF-Multimer alone managed 20 percent [1]. The CAPRI record shows the same trend from the practitioner side: one team integrated AlphaFold into its pipeline from Round 53 onward and, after sharpening the sampling strategy, significantly improved accuracy by Round 55 [9]. At CASP16, the ClusPro team reported that combining physics-based sampling with AF-based refinement produced high-accuracy models for cases where AF alone failed [10].

Rescoring is the second lever. The pyDock group's CAPRI workflow scores AF-Multimer models with a combination of physical interface energy and AF model confidence [11], and their methods chapter distills the broader lesson for difficult targets such as weak binders and flexible partners: generate a diverse pool of models and let classical energy scoring identify the near-native members [12].

Sparse homologs deserve special handling, because co-evolutionary signal dries up exactly where many interesting homomers live, including cross-species and engineered systems. Contact-prediction methods built on geometric and physical priors recover interface information without deep alignments, and combining one such method with AlphaFold 3 rescoring improved low-MSA performance by more than 30 percent in recent benchmarks [13].

The research frontier points the same direction. Reviewers attribute the remaining failures to pattern memorization under training-data scarcity and chart three hybrid routes to generalization: physics-based sampling to enrich inputs, strict geometric inductive biases in architectures, and energy functions that constrain generation [14].

Common Mistakes and Limitations

1. Folding one stoichiometry and stopping. The most common homomer error is committing to a dimer before the network has spoken. Run the sweep, then argue.

1. Treating rank 1 as the answer. Rank 1 is the best of one pool of stochastic draws. Pool all seeds and presets, count how many independent runs land on the same interface, and report the ensemble rather than the winner.

1. Reading ipTM without the PAE matrix. A scalar cannot distinguish one uncertain interface from a uniformly confident one. Always open the heat map.

1. Falling into the silent monomer trap. A FASTA with a single record is a legal monomer job, so a typo in the input produces a beautiful monomer model and no error message. Count chains in the output PDB every time.

1. Expecting paralog pairing to rescue a homomer. Paired MSAs help heteromers because different chains draw from different homolog families. Identical chains share one MSA, so interface signal must come from the sequence itself, templates, or learned priors.

1. Under-recycling large assemblies. Default recycling is tuned for speed. Large homomers routinely improve through a dozen or more passes, and an unconverged interface looks exactly like a wrong interface.

1. Measuring on unrelaxed coordinates. Unrelaxed AF-Multimer output carries clashes that distort contact distances and hydrogen-bond geometry. Relax before measuring, and relax only what you ranked.

1. Over-reading side chains and waters. Backbone-level interface topology is often right where individual rotamers and predicted water positions are speculative. Design experiments against the topology.

1. Reporting a static frame as the structure. Co-folding gives one snapshot of a flexible assembly, and interface motion is often functional. Pair the model with dynamics or ensemble experiments when the interface carries low confidence or known mobility.

1. Ignoring generalization limits. Accuracy degrades for sparse homologs, novel folds, large assemblies, and intrinsically disordered regions, the standing challenges of the AI docking era [15]. Treat out-of-distribution targets, especially engineered constructs and cross-species complexes, as cases that need orthogonal validation.

1. Forgetting that hard interaction classes stay hard. Even where AF-Multimer leads its comparison group, absolute performance can leave most of the problem unsolved, and low-quality models carry systematic structural biases that make them look locally plausible [16].

1. Skipping the run manifest. Versions, weights, seeds, and MSA database dates all change results. An unreproducible prediction is a dead end for you and for reviewers.

Frequently Asked Questions

Can AlphaFold-Multimer predict homo-oligomers such as trimers and tetramers?

Yes. Supply the sequence once per chain copy in the input FASTA and the network folds the full assembly. The stoichiometry is your choice, so test candidates in a batch rather than assuming one.

What ipTM value means a homomer model is trustworthy?

A common working rule treats ipTM above roughly 0.8 as likely correct and below about 0.6 as suspect. Values in between require the PAE matrix and independent evidence, because the scalar hides localized interface uncertainty.

Should I use the AlphaFold server or install AlphaFold-Multimer locally?

Use the server for a fast first look with no setup, and install ColabFold when you need seed sweeps, stoichiometry scans, recycling control, relaxation, or batch automation. Serious homomer work usually needs both at different stages.

How do I decide which stoichiometry to model?

Fold every plausible candidate from two copies upward and compare the best ranking metric across candidates. A wide margin is meaningful, a narrow one is not, and the winner must agree with solution biophysics and the literature.

Why do different random seeds produce different oligomer arrangements?

AF-Multimer sampling is stochastic, and symmetric assemblies often have several near-equal packing solutions. Seed disagreement flags ambiguity, while agreement across seeds is one of the strongest available reliability signals.

Do homomers need a paired multiple sequence alignment?

No. Paired alignments help when different chains come from different homolog families, which never happens for identical chains. The depth and quality of the single shared MSA still matters.

Why did my prediction return a monomer instead of a complex?

Because the input FASTA contained a single record. Repeat the record once per chain copy, or use the colon-separated single-line format, then confirm the chain count in the output PDB.

Can AlphaFold-Multimer capture conformational change during oligomerization?

Not reliably. Co-folding assumes a bound-like state, so large binding-induced rearrangements call for hybrid pipelines that combine AlphaFold-generated templates with physics-based docking and sampling.

Sources

1. Reliable protein-protein docking with AlphaFold, Rosetta, and replica exchange.
2. Revisiting Protein-Protein Docking: A Systematic Evaluation Framework.
3. Improving protein and protein interactions using pseudo-dimers derived from monomeric proteins.
4. Evaluation of protein-RNA Docking Web Servers for Template-Free Docking and Comparison with the AlphaFold Server.
5. AlphaFold and Docking Approaches for Antibody-Antigen and Other Targets: Insights From CAPRI Rounds 47-55.
6. EquiRank: Improved protein-protein interface quality estimation using protein language-model-informed equivariant graph neural networks.
7. EuDockScore: Euclidean graph neural networks for scoring protein-protein interfaces.
8. DynaBench: Dynamic data for the docking benchmark.
9. Protein Complex Structure Prediction With AlphaFold-Enhanced HDOCK in CAPRI Rounds 47-55.
10. Modeling Protein-Protein and Protein-Ligand Interactions by the ClusPro Team in CASP16.
11. Performance of pyDock in 8th CAPRI: Energy-Based Scoring Applied to Docking and AlphaFold Models.
12. Modeling Protein-Protein Complexes by Combining pyDock and AlphaFold.
13. Accurate protein-protein interactions modeling through physics-informed geometric invariant learning.
14. From memorization to generalization: Why physics will improve machine learning -based prediction of protein complexes.
15. Computational methods for modeling protein-protein interactions in the AI era: Current status and future directions.
16. A comparison of antibody-antigen complex sequence-to-structure prediction methods and their systematic biases.