Closing the loop: how cyclization works.

Definition

What is a head-to-tail cyclic peptide?

A head-to-tail cyclic peptide is a linear peptide in which the N-terminal amine of residue 1 and the C-terminal carboxyl carbon of residue L form a peptide (amide) bond:

The closing amide bond is chemically identical to every other amide bond in the chain (1.33 Å N–C bond length, planar, ω dihedral ≈ 180° in the trans configuration). There are no free termini.

The reaction is performed in solution after Fmoc SPPS synthesis of the linear protected peptide, typically with PyAOP/DIEA in DMF at 1 mM concentration (high dilution suppresses dimerization). It can also be performed on-resin via side-chain anchoring.

Four mechanisms

Why cyclic binders win.

Four mechanisms, all well-established in the peptide-drug literature:

Comparison

Cyclization strategies compared.

Six common strategies. Head-to-tail is Cyclic BindCraft's default; the others are either supported with extra configuration or on the future-work list.

Head-to-tail was chosen as the default because (a) it is the simplest chemistry; (b) it preserves the canonical backbone amide bonds AF2/MPNN were trained on; (c) RFpeptide proved that a single cyclic encoding handles it elegantly.

The problem

The computational challenge.

AlphaFold2 and ESMFold see a protein as a 1-D sequence of residues with a learned 2-D pairwise relative-position embedding. The structure module iteratively refines residue coordinates using these embeddings plus an MSA (or single-sequence) representation.

For a linear peptide of length L, the relative-position embedding for pair (i, j) is roughly bucketize(j − i). For (i=1, j=L), the value is L − 1, which falls outside the trained bucket range [−32, +32] once L > 33. AF2's structure module therefore treats residues 1 and L as "very far apart" — which is correct for a linear chain but wrong for a cyclic chain, where 1 and L are bonded neighbors.

Two consequences:

1. Hallucination fails. If you ask AF2 to design a cyclic peptide by hallucination, it has no signal that 1 and L should be close. The termini drift apart by 10–30 Å.
2. Validation fails. If you give AF2 a cyclic backbone as input and ask it to predict the structure from sequence alone, it will predict a linear structure with two floppy termini. The pLDDT around residues 1 and L will be poor, and the predicted structure will not match the true cyclic geometry.

The same applies to ESMFold, OmegaFold, and any other structure predictor trained on linear sequences.

The trick

RFpeptide's elegant solution.

The RFpeptide paper (Rettie, Juergens, Adebomi et al., Nat. Chem. Biol. 21, 1948–1956, 2025) introduces a strikingly simple fix: wrap the relative-position encoding for residues on the cyclic chain.

5.1 The cyclic 2D relative positional encoding

For any pair (i, j) on a cyclic chain of length N, the shortest path around the ring is min(|j − i|, N − |j − i|). RFpeptide implements this by:

seqsep = j - i  # raw separation
if seqsep >  N / 2:  seqsep -= N   # going the other way around is shorter
if seqsep < -N / 2:  seqsep += N

After this wrap, residues 1 and L on a 33-mer have seqsep = ±1, identical to a normal i, i+1 pair. AF2's structure module sees them as sequence-adjacent, and the trained priors (3.8 Å Cα–Cα distance, planar amide geometry) naturally kick in.

5.2 The cyclic bonded edge

RFpeptide adds a second feature: in the SE(3) graph's "bonded neighbor" matrix, the entry for (L, 1) is set to +1 (and (1, L) to -1), identical to what a real bonded pair would have. This tells the SE(3) transformer that those two residues are covalently connected — even though there is no explicit linker or chain break in the input.

5.3 Total cyclization code: ~50 lines

The entire cyclization machinery in the rfpeptides branch of RFdiffusion is:

• Embeddings.py::PositionalEncoding2D.forward (lines 25–56): wrap seqsep for cyclic-chain pairs. ~30 lines.
• util_module.py::get_seqsep (lines 101–133): add the bonded edge between first and last residue. ~20 lines.
• inference/model_runners.py (lines 284–303): build the cyclic_reses mask from cyc_chains. ~15 lines.

The Cyclic BindCraft port

Our cyclize_relpos in functions/cyclic_utils.py is a direct JAX port of RFpeptide's PositionalEncoding2D.forward:

def cyclize_relpos(relpos, cyclic_mask, L):
    """Port of RFpeptide's Embeddings.PositionalEncoding2D.forward cyclic wrap."""
    import jax.numpy as jnp

    abs_sep = jnp.abs(relpos)
    sign = jnp.sign(relpos)
    wrapped = jnp.where(abs_sep > L / 2.0,
                        sign * (abs_sep - L),
                        relpos)
    both_cyclic = cyclic_mask[:, None] & cyclic_mask[None, :]
    if relpos.ndim == 3 and both_cyclic.ndim == 2:
        both_cyclic = both_cyclic[..., None]
    return jnp.where(both_cyclic, wrapped, relpos)

Design decision

Option A vs. Option B.

The task brief considered two options:

Option B remains available for users who want maximum fidelity: install RFdiffusion's rfpeptides branch, generate cyclic backbones externally, and feed them into BindCraft's MPNN+FastRelax+filter pipeline. The Cyclic BindCraft patch is structured so this is a drop-in replacement at Stage 2 (binder_hallucination).

Enforced geometry

The amide bond geometry we enforce.

The closing amide bond is a normal peptide bond, so we enforce the canonical geometry:

These numbers are the same ones used by Rosetta's fa_standard residue parameter set for the canonical peptide bond, so the constraints do not fight the scorefunction during FastRelax.

Honest assessment

Known limitations & future work.

Open questions

Open scientific questions & future work.

1. Cyclic-aware MPNN. ProteinMPNN treats the binder as a linear sequence. A cyclic-aware inverse folder (e.g. an MPNN retrained on cyclic backbones, or a graph neural network that takes the cyclic adjacency matrix as input) might produce better sequences. The RFpeptide paper does not modify MPNN; neither do we. Future work.
2. Bicyclic and sidechain-bridged topologies. Currently only head-to-tail is supported. Extending to bicyclic (two DeclareBond calls + two cyclic wraps) or stapled (lactam) is conceptually straightforward but requires careful constraint bookkeeping.
3. D-amino acid inclusion. The pipeline can already accept D-amino acids if you swap in a D-enabled PyRosetta scorefunction and flip the relevant Cα coordinates. AF2's confidence on D-backbones is unreliable because it was not trained on them; AfCycDesign has the same limitation.
4. Length-aware cyclic encoding. The current cyclize_relpos divides by N/2 to decide when to wrap. For very short peptides (N < 10), the wrap is degenerate (every pair wraps). For very long (N > 60), the encoding loses discrimination. A length-adaptive wrap (e.g. learnable per-length) might help.
5. Oral bioavailability prediction. Cyclic BindCraft optimizes for binding affinity and structural closure. A filter that predicts oral bioavailability (e.g. via the chameleonicity score from the CycPeptMPDB benchmark) would be a useful addition.

These are research directions; for now, the cyclic-AF2 + constrained FastRelax + cyclic-aware filter pipeline is sufficient to produce synthesis-ready cyclic binders in a few hours per target.