ApexGO Optimizes Peptide Antibiotics With Generative AI

Why we are running out of antibiotics

Start with the scale of the problem, because it is what makes this work matter. Bacteria evolve, and every time we deploy an antibiotic widely, we hand them a reason to develop resistance to it. Over decades this has hollowed out our arsenal. For the most dangerous hospital bacteria, the Gram negative pathogens with their tough double membranes, we have been driven back to last line drugs like polymyxin B and colistin, older and more toxic agents kept in reserve. And now resistance to even those is spreading. The frightening prospect is a return to a world where a routine infection can kill.

Peptide antibiotics are one of the more hopeful answers. These are short strings of amino acids, the same building blocks that make up proteins, and many of them kill bacteria by physically disrupting the microbial membrane rather than by a specific molecular lock and key. That physical mechanism is harder for bacteria to evolve around, which is exactly why they are attractive. The problem is design. A peptide of modest length can be arranged in more ways than there are atoms in the observable universe, and we understand only crudely how a given sequence translates into antibiotic strength. Finding a good one is a needle in an impossibly large haystack.

Machine learning has already sped up the search, mostly by screening fixed libraries of candidates or by generating new peptides broadly. But Marcelo Torres, Cesar de la Fuente-Nunez, and their colleagues point out a gap in how these tools are used. Most of them generate candidates in the abstract, when the practical task that dominates real drug development is different. You usually already have a peptide that works a little, and you want to make it work better, while keeping it similar enough to the original that it stays synthesizable and safe. That is lead optimization, and it is the problem ApexGO is built for.

Turning antibiotic design into a search problem

The core reframing is to treat antibiotic design as optimization. Imagine every possible peptide as a point on a vast landscape, with height representing antibiotic potency. Designing a better antibiotic means climbing to a higher point. The trouble is that this landscape is discrete and jagged, made of individual sequences where changing one amino acid can swing the potency wildly, and you cannot take smooth steps across it.

ApexGO’s first move solves this. It trains a transformer variational autoencoder, a neural network that learns to compress any peptide sequence into a point in a smooth continuous space, and to decode any point back into a sequence. The authors pretrained it on about 4.5 million peptide sequences, so it learned the general grammar of what peptides look like. Once you have this space, the jagged discrete search becomes a smooth continuous one. You can move a little in the space, decode the new point, and get a peptide that is a small variation on where you started. The impossible landscape has been made navigable.

The second move is how to search it, and here the authors use Bayesian optimization, a technique built precisely for expensive searches where each evaluation costs a lot. In their setup the evaluation is a separate deep learning model called APEX, which predicts a peptide’s minimum inhibitory concentration, the lowest dose that stops bacteria from growing, across eleven pathogens. APEX acts as the oracle, the judge of potency. Because asking the oracle is not free, Bayesian optimization builds a cheap statistical model, a Gaussian process, that guesses the oracle’s answer everywhere based on the points it has already tried, and uses that guess to decide where to look next. It balances exploring uncertain regions against exploiting places that already look good.

Combining generative AI and Bayesian optimization represents a substantial methodological departure from most successful prior work that used supervised learning to virtually screen large but fixed databases of molecules. Torres and colleagues, on what makes ApexGO different

The pieces that make it work

Three refinements turn this general idea into a system that produces usable antibiotics. The first is that the search happens in the autoencoder’s latent space and the two models are updated together. As optimization proceeds, the network periodically reshapes its space so that peptides with similar potency sit near each other, which makes the landscape smoother and the search more effective. This joint updating, drawn from the authors’ earlier work on latent space Bayesian optimization, is what lets the method keep improving rather than stalling.

The second is trust regions. In a high dimensional space it is easy for a search to wander off into regions the models understand poorly and waste effort. A trust region is a box drawn around the best peptide found so far, confining the search to a neighborhood the models can reason about. The box grows when the search is succeeding and shrinks when it is failing, adapting to how well things are going. ApexGO runs twenty of these trust regions at once, so it optimizes twenty distinct peptides in a single run rather than betting everything on one, which raises the odds that several of them will pan out in the lab.

The third, and the one that makes the results trustworthy for drug development, is a similarity constraint. Left unconstrained, an optimizer might propose a peptide with wonderful predicted potency that looks nothing like the starting molecule, and such wild jumps are risky, harder to synthesize and more likely to be toxic or to fool the oracle. So ApexGO requires every proposed peptide to stay at least seventy five percent similar to its template. It optimizes under a leash, which keeps the designs realistic.

The whole loop can be written compactly. The optimizer searches the latent space for the point whose decoded peptide the oracle scores best, subject to staying close to the template.

Here \(D\) decodes a latent point into a peptide, \(f’\) is the APEX oracle scoring its potency, and \(C\) measures similarity to the template. The elegance is that a hard, discrete, constrained design problem has become a continuous optimization that standard machinery can attack.

Resurrecting antibiotics from extinct animals

The choice of starting peptides is one of the more evocative parts of the work. The ten templates were mined from the proteins of extinct organisms, including the woolly mammoth Mammuthus primigenius, the giant ground sloth Mylodon darwinii, and the sea cow Hydrodamalis gigas. The authors call this molecular de-extinction, the idea that the proteins of long dead species contain antimicrobial sequences that evolution has stopped using and that might sidestep the resistance modern bacteria have built up. The optimized peptides carry names like mammuthusin and mylodonin, after the animals whose proteins seeded them.

The templates were deliberately chosen to be only moderately active, with room to improve, so that a meaningful boost was possible. Starting from something already near perfect would leave little to demonstrate. This is a realistic simulation of lead optimization, taking a middling candidate and pushing it toward the potency a real drug would need.

What happened when they made the molecules

Predictions are cheap and easy to oversell, which is why the most important part of this paper is that the team physically synthesized a hundred of ApexGO’s designs and tested them against eleven clinically relevant bacterial strains, including ones resistant to conventional antibiotics. This is the ground truth that separates a real result from a promising simulation.

Of the hundred synthesized peptides, eighty six showed detectable antibiotic activity, an eighty six percent hit rate. Sixty eight percent were more active than the template they were optimized from, and against the hard Gram negative pathogens specifically that improvement rate rose to seventy two percent. The authors frame an eighty five percent ground truth success rate at enhancing activity against Gram negative bacteria, and note it outperformed previously reported methods for antibiotic optimization. The oracle was not perfect, with a correlation to measured potency around 0.46, but it was a good enough compass to steer the search toward molecules that worked in reality.

They went further than a dish. In two preclinical mouse models of infection with Acinetobacter baumannii, one of the most feared drug resistant hospital pathogens, the best optimized peptides were tested as real treatments. In a skin abscess model, the optimized peptide mylodonin-2-3 reduced the bacterial load by up to four orders of magnitude and cleared the infection faster than the controls, outperforming polymyxin B and levofloxacin by about an order of magnitude at the earlier time point. In a deep thigh infection model using immune suppressed mice, another optimized peptide reduced bacterial counts by three orders of magnitude, matching the control antibiotics. The mice showed no toxicity, holding stable weight throughout. Effects that survive the jump into a living animal are far more convincing than numbers from a plate.

How it stacks up against other generative methods

The authors benchmark ApexGO against two strong generative peptide models, HydrAMP and PepDiffusion, on the same constrained optimization task, and the comparison exposes something important about the difference between generating and optimizing. When asked to produce derivatives that stayed at least seventy five percent similar to the templates, HydrAMP satisfied that constraint for only a small fraction of its proposals, between roughly a fifth and a fraction of a percent depending on settings, and PepDiffusion produced none at all that cleared the bar for every template.

The reason is instructive. Those methods are trained to generate peptides that resemble their training data of known antimicrobial peptides, so they are excellent at producing novel candidates in the abstract but poor at hugging close to a specific starting molecule that may not look like a typical antimicrobial peptide. ApexGO, by contrast, is an optimizer guided by the oracle rather than by a training distribution, so it can climb toward high potency in unfamiliar sequence neighborhoods that generative models cannot reach. The distinction between one shot generation and iterative optimization is the whole point, and the benchmark makes it concrete.

How the peptides kill, and whether they are safe

Beyond potency, the team studied how the optimized peptides act and whether they harm human cells. Using fluorescent probes, they showed that many of the peptides permeabilize the bacterial outer membrane and depolarize the inner one, consistent with the membrane disrupting mechanism that makes peptide antibiotics attractive against resistance. Interestingly, there was no tidy relationship between a peptide’s folded shape and its activity, which suggests antibiotic strength can arise from several structural routes rather than one.

On safety, they tested every derivative against human embryonic kidney cells and found that most were non toxic at the highest concentration used in the activity assays. A few showed mild to moderate toxicity, and the paper reports these honestly rather than burying them. They also probed stability against the enzymes in blood serum that chew up peptides, and found that one derivative resisted degradation markedly better than its parent, which they traced to specific amino acid swaps. These are the practical properties that decide whether a promising peptide can ever become a drug, and testing them is a sign the work is aimed at real translation rather than a benchmark score.

Reproducing the optimization engine

The full system needs a peptide autoencoder trained on millions of sequences and a validated antibiotic oracle, but the optimization engine at its heart, latent space Bayesian optimization with a Gaussian process surrogate, a trust region, and a similarity constraint, is compact and reproducible. The implementation below writes exactly that. It searches a continuous latent space for the point an oracle scores highest, staying inside a similarity ball around a template, and compares this guided search against random sampling under the same budget. A runnable smoke test shows Bayesian optimization finding a far more potent point than random search, the same efficiency that lets ApexGO succeed within a small experimental budget.

# Latent space Bayesian optimization with a trust region and a
# similarity constraint, the optimization engine behind ApexGO from
# Torres, Zeng, Wan, et al., "A generative artificial intelligence
# approach for peptide antibiotic optimization" (Nature Machine
# Intelligence 2026). The VAE latent space and the APEX oracle are
# replaced by a toy latent space and a toy potency function.

import torch
import math

D = 6                                # VAE latent dimension (toy)
torch.manual_seed(0)
Z_TEMPLATE = torch.zeros(D)          # template peptide, center of the search
RADIUS = 2.5                       # similarity constraint, the 75 percent leash
Z_OPT = torch.randn(D); Z_OPT = Z_OPT / Z_OPT.norm() * 1.8   # the true optimum


def oracle(z):
    """APEX style potency. Higher is more potent, peak at Z_OPT."""
    return (-((z - Z_OPT) ** 2).sum(-1)).unsqueeze(-1)


def in_constraint(z):
    """Stay within the similarity ball around the template."""
    return ((z - Z_TEMPLATE) ** 2).sum(-1).sqrt() <= RADIUS


def rbf(A, B, ls=1.2, var=1.0):
    d2 = ((A[:, None, :] - B[None, :, :]) ** 2).sum(-1)
    return var * torch.exp(-0.5 * d2 / ls ** 2)


class GP:
    """Exact Gaussian process surrogate with an RBF kernel."""
    def __init__(self, X, y, ls=1.2, var=1.0, noise=1e-4):
        self.X, self.ls, self.var = X, ls, var
        K = rbf(X, X, ls, var) + noise * torch.eye(len(X))
        self.L = torch.linalg.cholesky(K)
        self.alpha = torch.cholesky_solve(y, self.L)

    def posterior(self, Xs):
        Ks = rbf(Xs, self.X, self.ls, self.var)
        mu = (Ks @ self.alpha).squeeze(-1)
        v = torch.cholesky_solve(Ks.t(), self.L)
        cov = rbf(Xs, Xs, self.ls, self.var) - Ks @ v
        return mu, torch.clamp(torch.diag(cov), min=1e-8)


def thompson(gp, cand):
    """One posterior sample, the acquisition that picks the next peptide."""
    mu, var = gp.posterior(cand)
    return mu + var.sqrt() * torch.randn_like(mu)


def sample_ball(center, radius, n):
    """Uniform points inside a ball of the given radius."""
    v = torch.randn(n, D); v = v / v.norm(dim=1, keepdim=True)
    r = radius * torch.rand(n, 1) ** (1.0 / D)
    return center + v * r


def run_bo(budget=30, ninit=6, seed=0):
    """Bayesian optimization with an adaptive trust region."""
    torch.manual_seed(seed)
    X = sample_ball(Z_TEMPLATE, RADIUS, ninit); y = oracle(X)
    tr = 1.5                            # trust region radius
    succ = fail = 0
    for _ in range(budget - ninit):
        best_z = X[y.argmax()]
        cand = sample_ball(best_z, tr, 256)
        cand = cand[in_constraint(cand)]     # enforce the similarity leash
        if len(cand) == 0:
            cand = sample_ball(Z_TEMPLATE, RADIUS, 256)
            cand = cand[in_constraint(cand)]
        zc = cand[thompson(GP(X, y), cand).argmax()]
        yc = oracle(zc.unsqueeze(0))
        if yc.item() > y.max().item():
            succ += 1; fail = 0
        else:
            fail += 1; succ = 0
        if succ >= 3: tr = min(tr * 2, RADIUS); succ = 0   # grow on success
        if fail >= 5: tr = max(tr / 2, 0.2); fail = 0  # shrink on failure
        X = torch.cat([X, zc.unsqueeze(0)]); y = torch.cat([y, yc])
    return y.max().item()


def run_random(budget=30, seed=0):
    """Random search within the constraint, the fair baseline."""
    torch.manual_seed(seed)
    X = sample_ball(Z_TEMPLATE, RADIUS, budget)
    return oracle(X[in_constraint(X)]).max().item()


def smoke_test():
    """Bayesian optimization beats random search under the same budget."""
    bo = sum(run_bo(seed=s) for s in range(5)) / 5
    rd = sum(run_random(seed=s) for s in range(5)) / 5
    assert bo > rd, "Bayesian optimization should outperform random search"
    print("true best potency        0.000  (at the optimum)")
    print("Bayesian optimization  {:.3f}  (mean over 5 seeds)".format(bo))
    print("random search          {:.3f}  (mean over 5 seeds)".format(rd))
    print("guided search finds a far more potent peptide, smoke test passed")


if __name__ == "__main__":
    smoke_test()

The honest note is that this is the search engine, not the biology. Real peptides live in a learned latent space trained on millions of sequences, the oracle is a validated antibiotic predictor rather than a smooth toy function, and the payoff is a molecule you can synthesize. The mechanism is faithful, though. A Gaussian process surrogate guides an adaptive trust region toward high scoring points inside a similarity constraint, and it reaches a much better peptide than random search on the same budget, which is precisely why ApexGO can find winners while synthesizing only a hundred candidates.

From the bench to the bedside

It is important to place these results at the right point on the long road to a medicine. What ApexGO produced is early stage research, validated in test tubes and in mice, which is genuinely encouraging but still far from a drug a doctor can prescribe. The history of antibiotic development is full of compounds that killed bacteria beautifully in a dish, worked in mice, and then failed in humans because of toxicity, poor absorption, rapid breakdown, or effects that only appear at the scale and complexity of a human body. Mouse infection models are a meaningful hurdle, not the finish line.

The authors are careful about this, and their care is worth echoing. They state explicitly that their comparisons with the last resort antibiotics were meant as contextual benchmarks, a way to give a sense of scale, and not as claims that these peptides are therapeutically equivalent to approved drugs. They also lay out what a real development path would require, pairing the potency gains with further engineering for stability and for the pharmacokinetic properties that determine whether a peptide survives long enough in the body to work. A peptide that is potent but degrades in minutes, or that the kidneys clear instantly, is not yet a treatment.

The honest framing is that this is a tool that accelerates the earliest and most searching part of antibiotic discovery, generating strong, synthesizable candidates and weeding out weak ones fast, so that human effort and expensive later stage testing can focus on the most promising few. That is valuable precisely because the early search is where so much time and money evaporate. It is not a claim that a cure for resistant infection has arrived.

Honest limitations

Beyond the distance to the clinic, the method has boundaries the authors name plainly. The oracle, APEX, was trained on eleven specific bacterial pathogens, so it cannot be pointed at a new strain without retraining, which limits how broadly the system generalizes. The authors suggest incorporating genomic features so that future versions could predict activity against pathogens they were never trained on, through few example or zero example learning, but that is future work.

The optimization also chased a single property, antibiotic potency, whereas a real drug has to balance many at once, potency against toxicity against stability against manufacturability. ApexGO optimizes one dimension well, and the authors point to multiproperty optimization as the natural next step, since a peptide that is potent but unstable or toxic is a dead end. The trained oracle’s correlation with measured potency, around 0.46, is also a reminder that it is an imperfect guide, good enough to enrich for winners but far from an exact predictor, so wet laboratory validation remains essential rather than optional.

There is also a subtler point about what the benchmarks show. ApexGO clearly beat generative baselines at constrained optimization, but that comparison partly reflects that those baselines were built for a different job, unconstrained generation. The fair reading is that ApexGO is the right tool for lead optimization specifically, not that it is universally superior to every generative model. And the explainability of why the oracle favors certain edits remains thin, something the authors flag as an open direction, which matters if these designs are ever to earn the trust required for clinical development.

What this changes for antibiotic discovery

The practical shift is toward treating antibiotic design as a guided optimization loop rather than a screen or a blind generation. By coupling a learned space of peptides with an oracle and an efficient search, ApexGO can propose a small set of high quality, synthesizable candidates that respect real design constraints, which is exactly the shape of problem a medicinal chemist faces. The eighty six percent hit rate on synthesized molecules is what makes this credible, because it means the search is not just optimizing a number but finding molecules that hold up when actually made.

The molecular de-extinction angle also reframes where new antibiotics might come from. If the proteins of extinct species are an untapped library of antimicrobial sequences that modern bacteria have never encountered, then optimization tools like this one are a way to mine that library efficiently. The broader lesson, that a well designed search with the right constraints can outperform larger and less focused generative models, echoes across machine learning applied to biology. For readers following that thread, this work sits alongside other computational efforts to read and design biological systems, from mapping the gene networks that govern cells to the medical machine learning collected under the medical AI pillar, and it shares the design instinct behind other targeted models such as multi headed networks for reading pathology slides.

Conclusion

The core achievement of this work is a generative artificial intelligence system that optimizes existing peptide antibiotics under realistic constraints, and whose designs were validated not only in silico but in the laboratory and in living animals. By combining a peptide autoencoder with Bayesian optimization and an antibiotic oracle, ApexGO turned a jagged, discrete design problem into a smooth guided search, and it found molecules that worked, with an eighty six percent hit rate and potent activity against a feared drug resistant pathogen in two mouse models.

The conceptual shift is from generating to optimizing. Where most machine learning tools for peptides either screen fixed libraries or generate candidates broadly, ApexGO embraces the actual task of drug development, improving a promising lead while keeping it close to the original. The similarity constraint, the trust regions, and the joint updating of the space and the surrogate are what make that constrained climb effective, and the benchmark against generative baselines shows how much that focus matters, since those methods could barely satisfy the constraint at all.

The ideas extend well beyond antibiotics. The same optimize a lead under constraints framework applies to any peptide or protein design problem where a good starting point exists and a scoring oracle can be built, and the authors have already sketched how genomic features and multiproperty objectives could broaden it. The general recipe, a learned space plus an oracle plus efficient constrained search, is one the wider field of molecular design can reuse.

The limitations keep the achievement in proportion. The oracle is tied to eleven pathogens and is an imperfect predictor, the optimization targeted potency alone, and above all the results live in mice, not people, with the authors themselves cautioning that their antibiotic comparisons are contextual rather than claims of equivalence. None of this diminishes what was shown, but it frames it correctly, as a powerful accelerator for the earliest stage of antibiotic discovery rather than a finished therapy.

What lingers is the shape of the answer to a frightening problem. Antibiotic resistance is outrunning our ability to design drugs by hand, and rather than wait for inspiration, this work turned the design of a better antibiotic into a search a machine can run, guided by what already works and disciplined by what can actually be made. Point that search at the forgotten proteins of extinct animals, and it starts returning molecules that clear infections in mice. That is a small, carefully validated step, and against a threat this large, small validated steps are exactly what is needed.

Frequently asked questions