Synthesizability by construction: design the route, not the molecule

Synthesizability in de novo drug design is usually handled after the fact. A model draws a structure, a scoring function guesses how hard it looks to make, and a chemist finds out later whether that guess was worth anything. The alternative is to make the route part of what gets designed, so an unmakeable molecule is not scored badly but is impossible to propose.

The difference sounds like bookkeeping. It changes what the model is able to tell you.

A generator that emits SMILES has thrown the route away

If your model outputs a structure, it has no ground truth about how that structure came to be, because it never had one. You can run retrosynthesis afterwards and often it works. But the model cannot report which reaction formed which bond, cannot tell you that two candidates share a reagent, and cannot tell you how different two routes are, because it never held a route in the first place.

Synthetic accessibility scores paper over this. They are heuristics fitted to fragment frequencies, and they answer "does this look like the sort of thing people make". That is a genuinely useful signal and it is not the same as a route.

What we design instead

Our search does not evolve molecules. It evolves five integers.

A candidate is a scaffold, a building block, a reaction, a second building block and a second reaction. To evaluate it the engine runs the reactions and sees what comes out. If a step does not fire, the recipe falls back to another reaction it can fire, then to a direct attachment, and if both steps end up as direct attachments the candidate is discarded outright, because the route printed beside it would be fiction.

That last rule is the whole posture in one line. We would rather deliver fewer molecules than deliver one whose route we cannot defend.

Three things this makes computable

Route novelty

Because a candidate is a recipe, the distance between two candidates can be measured over the recipe rather than the structure. Two molecules that look similar but are assembled from different blocks through different chemistry are genuinely different pieces of work for a lab. A structure-first generator cannot compute this at all.

Analogue series that share a route

Hold the scaffold and both reactions fixed and swap one building block, and you get a set of analogues that all run through the same chemistry. That is an orderable series rather than a list of unrelated suggestions. In a live run this produced 119 analogues with similarity falling from 0.89 to 0.79 across the set.

Genotoxicity screening on the reagents

A DNA-reactive handle on a building block is a real risk even when it is consumed during the reaction and absent from the final product. Product-only mutagenicity prediction cannot see it, because by the time the product exists the alert is gone. Screening the route inputs catches it at design time, before anyone orders anything.

What it costs, measured

Running real reactions during a search is expensive, so the interesting question is how many products you get per reaction attempted. We built a model that learns which reaction template is most likely to fire given the functional groups present, and used it to order the attempts. Nothing is skipped, so the set of reachable products is identical. Only the order changes.

Across 24 paired experiments spanning eight targets and three seeds, that reordering won every pair. On held-out reactant pairs the model separates fire from no-fire at AUC 0.9460, against 0.6372 for the hand-written rule table it replaced.

The failure this posture is designed to catch

Working in routes does not make you right. It makes you auditable, which is different and more useful.

One of our reaction templates, the only route to an N-aryl azole bond, shipped as active and could never fire. The pattern specified an aliphatic nitrogen where the chemistry needs an aromatic one. Pyrazole returned nothing. Imidazole returned nothing. Tetrazole returned nothing. It had even been given a fresh reagent profile specifically to support that bond, which it was incapable of forming.

Nothing caught it for the length of its life, and the reason is worth sitting with: a template that never fires produces no wrong molecules. It produces no molecules. A missing route and a hard target look identical from the outside.

The fix was a test asserting the invariant rather than the instance: every template marked active must fire on something. That is the pattern we now reach for by default, because the same class of bug had already been fixed twice on one target at a time and reappeared just outside each previous guard.

A benchmark result that is not an achievement

Reaction-first generators score 1.0 on validity, uniqueness and novelty on the standard distribution-learning benchmark. We do not lead with that, because for a generator built this way those three numbers are tautological. Every molecule is valid because a reaction produced it. Leading with a metric your architecture cannot fail is a way of sounding measured while saying nothing.

Why we build this way

We cannot claim better potency prediction on novel chemotypes, and the applicability domain problem explains why we think nobody currently can. What we can guarantee is narrower and checkable: every candidate we deliver has a route, named reagents, and a genotoxicity screen run over the inputs to that route.

• ·See a full candidate dossier on the worked candidate page.
• ·The pipeline end to end is written up in Methods.
• ·Which targets we design against, and why the list splits in two, is covered in lifespan versus rejuvenation targets.