Generating lipids, not molecules

If you believe delivery is the bottleneck in genetic medicine — I do — the obvious next question is whether generative models can design the molecule at the center of it. The ionizable lipid is the component of a lipid nanoparticle that grabs the nucleic-acid cargo, protects it, and carries it across the endosomal membrane into the cell. It's the part that most determines whether an LNP works, and it's still discovered mostly the old way: take a human-drawn library, vary a few positions, screen what you made. So the instinct to point a generative model at it is right. It's also more subtle than it looks, and most of the subtlety lives in the parts people skip.

Start with what "AI for LNPs" usually means today. Almost all of it is predictive or library-bound: featurize a fixed set of candidates somebody already enumerated, train a model to rank them, maybe close an active-learning loop that keeps picking the next batch from that same set. That's genuinely useful, and it isn't what I'm talking about. Generation asks a different question — not "which of these is best?" but "which new lipid, on no one's list, should we make?" The moment you ask that, the search space stops being a spreadsheet and becomes open-ended, and every soft assumption in how you framed the problem shows up in what the model draws.

The molecule isn't the unit

Here's the mistake that sinks the naive version. You take a generative model trained on drug-like molecules, aim it at lipids, and let it propose structures. What comes back is two kinds of useless: things no one can synthesize, and things that look reasonable on paper but were never judged as what they actually are. An ionizable lipid isn't a small-molecule drug that works by docking into a binding pocket. It's a flexible amphiphile whose function only appears after it self-assembles — with a helper phospholipid, cholesterol, a PEG-lipid, and the RNA cargo — into a particle. And that particle isn't a fixed object either: its size, charge, internal structure, and how much RNA it actually encapsulates depend on the ratios you mixed and the process you mixed them with. The unit of design is the formulated particle in a body, not the lipid drawn in isolation. Optimize the molecule by itself and you've optimized one coordinate of a much larger object.

So generative lipid design has to be lipid-centered but LNP-aware. In practice that means five things have to be specified together, and skipping any one is where projects quietly fail: the chemical object you generate, the data and objectives that steer it, the synthesis routes that make it real, the formulation context it assembles in, and the particle and biological readouts that decide whether it worked. The rest of this is really just those five, one at a time.

What you're actually generating

An ionizable lipid isn't a generic graph of atoms; it has parts, and the parts do specific jobs. There's an ionizable headgroup, usually an amine, that stays mostly neutral in the blood and picks up positive charge in the acidifying endosome — that protonation is what drives escape, and its apparent pKa (empirically, somewhere near 6.5 for lipids that deliver well to the liver) is one of the few numbers that reliably predicts anything. There are the linkers joining head to tails, and whether they're esters or amides largely sets how fast the lipid breaks down and clears — which is most of the difference between something you can dose once and something you can dose again. There are the tails themselves, whose length, saturation, and branching set how the molecule packs, which feeds particle stability and the fusogenicity that helps it escape. And increasingly the whole thing is modular, assembled from combinatorial reactions of amine cores with tail-bearing building blocks, which is exactly why the libraries got so large in the first place.

None of that is decoration. Each feature couples to synthesis (can you make it), to formulation (does it assemble into a stable particle), and to biology (where it goes and whether it's tolerated). A generator that treats a lipid as an undifferentiated bag of atoms throws away all of this structure and then spends its capacity rediscovering that headgroups and tails are different things. The better framing makes those parts first-class: generate over headgroups, linkers, and tails as structured, swappable components, condition on the properties each is known to control, and vary within a space that already respects what a lipid is.

How you represent it

Which raises the question of representation, and representation is not a detail — it's the prior that decides what the model is even allowed to vary, preserve, or condition on. Plain SMILES strings are easy to generate and easy to generate wrong; a model will happily emit strings that don't parse into real molecules. SELFIES fix validity by construction, which matters more than it sounds when you're generating rather than reading. Molecular graphs make connectivity explicit and are natural for anything that reasons about substructure. Fragment- and building-block representations generate in chemically sensible chunks instead of atom by atom, which improves realism and makes synthesizability tractable at the same time. Reaction trees go further and represent a molecule by the route that makes it. And for the assembly question specifically, coarse-grained descriptors — the kind used in simulations that predict how amphiphiles pack — carry information atom-level graphs don't. There's no single right answer. The point is that choosing a representation is choosing what your generator can and can't say, and for lipids you usually want one that keeps the modular head/linker/tail structure and the synthetic route in view.

Then there's the data the model and its scoring functions have to learn from, and this is where the field is honestly thin. What you want is lipid structures tied to their synthesis routes, the formulation they were tested in, the cargo, the particle characterization, and the assay protocol — one coherent record per experiment. What exists in public is a scatter of structures with potency numbers, measured in different systems under different conditions, mostly reporting the ones that worked. The failures — the overwhelming majority, and the most informative examples a generator could see — almost never get published. And because related lipids share scaffolds, a naive train-test split leaks badly: the held-out lipid is a near-neighbor of something in training, the model looks excellent, and it has learned almost nothing that transfers to a genuinely new scaffold. Split by scaffold or by series instead and a lot of impressive numbers deflate. Underneath all of it, the labels themselves are context-dependent — the same lipid reads differently at a different dose, route, cargo, or formulation — so a "delivery" measurement is a property of the molecule in a setting, not of the molecule. Train a predictor on structure alone and it is conditioning on a fraction of the causes.

How you generate

With the object, the representation, and the data in view, the model family matters less than people think — and it matters in a particular way. It's more useful to compare methods by the design operation they give you over lipid space than by architecture name. Autoregressive token or grammar models build a structure symbol by symbol. Graph and fragment methods assemble it from pieces. Reaction- and building-block-based methods generate the route and get a makeable molecule as a byproduct. Constrained diffusion and flow-based methods start from noise and denoise toward a structure while holding constraints — a natural fit when "must be synthesizable" and "must hit these properties" both have to hold at once. Sitting on top of any of these are the search policies that actually drive exploration: Bayesian optimization, evolutionary methods, reinforcement learning, Monte Carlo tree search, active learning. The question to ask of any of them isn't whether it's fashionable; it's how it handles lipid modularity, how it enforces synthesizability, how it represents uncertainty, and whether it can steer toward several objectives at once under a formulation-conditioned goal.

Makeable, or it doesn't count

That last point deserves its own section, because synthesis is where most generated lipids die. A generator that proposes structures nobody can make isn't proposing candidates; it's producing rejections at scale. The set of reactions you can actually run — the building blocks on the shelf, the couplings that work, the steps a chemist will tolerate — is what defines the space worth exploring, and it belongs inside the model rather than in a filter bolted on at the end. Filtering after the fact wastes most of the model's output and biases what's left in ways you don't control. Generating the route and the molecule together, or restricting generation to reachable products of known chemistry from the start, is the difference between a list of ideas and a list of experiments. This is the problem our own work on synthesis-constrained diffusion for ionizable lipids goes after: keep the generator inside makeable chemistry so that every proposal is something a lab could make next week.

Synthesis and steering are two halves of the same problem. Feasible chemistry defines what can be proposed; guidance defines which of the makeable proposals earn bench time. Those are different operations and worth keeping distinct — specifying a target up front, generating conditionally toward it, and scoring candidates with an oracle are not the same thing, and conflating them is how you end up climbing a proxy nobody meant to optimize.

What do you score against?

Which brings it to the oracle, the scoring function that stands in for reality during the search — and the part it's most tempting to get wrong. The easy version collapses everything to a single potency number and lets the model climb it. That reproduces the exact failure I've written about before: potency is the thing that's easiest to measure and among the least predictive of whether a lipid becomes a drug. A real oracle is multi-output and context-conditioned. It has to say something about potency, yes, but also tissue selectivity, tolerability, biodegradation, formulation compatibility, and how all of it shifts with the cargo — objectives that are separate and sometimes in direct tension, since the membrane disruption that buys potency is the same thing that buys toxicity. It has to carry uncertainty, and that uncertainty has to be calibrated, because a search will find and exploit an overconfident oracle's blind spots faster than you can say Goodhart. And it should keep a clean line between the endpoints you use to steer generation and the biological tests you hold out to check it, or you end up grading the model on its own homework.

Formulation is where a lipid-only oracle finally breaks, and it can enter the model in several ways depending on how much you trust it: as metadata attached to each record, as explicit conditioning variables the generator sees, as physical priors from coarse-grained assembly models, or as downstream oracles that take a proposed lipid plus a formulation and predict a particle. The variables that belong in that picture are concrete — the identity of the co-lipids, the molar ratios, the cargo, the buffer, the mixing conditions — and then the particle properties they produce: size, polydispersity, encapsulation efficiency, morphology, and stability. A generative workflow that never names these is quietly assuming they're fixed, and they are not.

How you'd know it's working

All of this changes what a benchmark is supposed to measure. Molecule-level validity and novelty — is the structure legal, is it new — are table stakes and mostly beside the point; a model can ace both and still be useless. The benchmark that matters follows the whole funnel: how many structures were generated, how many survived filtering, how many had a real synthesis route, how many were actually made and purified, how many formulated into stable particles, how many were characterized and tested, and how many of those worked. Every stage has attrition, and where the attrition happens tells you what the model is actually bad at.

If I had to write down a minimum reporting standard for a prospective lipid-generation study, it would be roughly this: the counts at every stage from generated to tested; the negative results, not just the hits; the formulation and assay metadata that make a number interpretable; uncertainty estimates on the predictions; the nearest-neighbor similarity of each tested lipid to the training set, so a reader can see whether the model invented something or interpolated between things it already knew; and the train-test split rule, stated plainly, that keeps related lipid series from bleeding across it. The validation that actually counts is prospective — make the lipids the model proposed and test them — not another retrospective re-ranking of a held-out list, which mostly measures how well the split was gamed.

Where this goes

The near-term problem is narrow on purpose: generate makeable ionizable lipids, judged in their formulation, against objectives that matter. But the framing extends. The ionizable lipid is one component of a particle that also has helper lipids, PEG, cargo, and — if you want to leave the liver — targeting elements, and each of those is its own design problem with its own generative treatment. The longer arc is generating the stack, not just the lipid: co-designing the lipid, the formulation, and eventually the targeting so the whole particle is aimed at a tissue rather than assembled and hoped over. None of it works without the boring foundation, which is high-throughput, well-recorded data generated under conditions consistent enough to learn from — the substrate the public literature doesn't provide and someone has to build.

The through-line is that the interesting work here isn't a bigger model. It's specifying the problem so the output survives contact with reality — makeable chemistry, physical priors, context-aware and calibrated oracles, honest benchmarks, prospective tests. Generative AI will earn its place in delivery when it's constrained by what a lab can build and what a body will tolerate, and not before. That's the version worth building, and it's the one we're building.