Building Optagon Labs

AI has made it dramatically fast to discover new drugs with a certain biological function, such as killing a cancer cell. Bringing this drug to humans is still bottlenecked by the pre-clinical engineering process. It’s a phase where the drug developer spends years optimizing the molecule for the human body, trying to find a design with acceptable performance.

Drug engineering is a multi-variable, high-dimensional design problem where real-world verification is needed at every step. Here, teams of up to 300 scientists juggle many long-context design challenges that arise every day. For example, a team must make a drug soluble in the blood and with the right potency to take effect. Then it must create a formulation (such as an oral pill) that releases the drug at the right rate in the blood so that it doesn’t release all at once and harm the patient. They also have to ensure that the designed pill itself can be manufactured at scale. This is just one simplified example of a design problem, out of hundreds of interconnected design problems that arise in drug engineering.

We see a future where frontier AI continues to become capable of predicting individual endpoints, such as inferring the chemical properties of a drug, the performance of a formulation, or certain aspects of human biology, driven by new model architectures, scientific data factories, and discovery loops. Those methods are helpful, but we believe that they are not enough to solve the drug engineering problem because they assume an incomplete shape for the problem and the solution: they optimize for an objective that won’t necessarily lead to the success of the whole program, because causality and action are confined within a silo that only focuses on a limited slice of the program.

To put it in simple terms, you can predict that a molecule is safe with high accuracy and decide to pursue it, but this won’t tell you anything about the billions of long-horizon consequences of this decision (how it interplays with other critical properties, how it links to next experiments, the effects on formulation, next action with a supplier, and the most informative next optimization campaign under the remaining budget). A prediction made by a model won’t expose all the paths to explore, and how to validate such paths to maximally derisk the program. This is still something left to the intuition of the drug developer, who can’t reason in multi-dimensional, long-horizon systems.

Drug engineering has a distinct problem shape: it’s a sequential search across multiple stages, under high uncertainty. Every design decision opens a vast space of further decisions, and a choice made at one stage can decide what’s possible at every stage after it. A single frontier model, a self-driving lab, a robot that generates massive amounts of data are not a solution; they are pieces of a grand puzzle of what should define the future of pharmaceuticals R&D. In this essay, we define that future and the principles behind it, and describe what it takes to build it: an AI-native R&D company that decides what each program should test next, runs those experiments across the R&D value chain, and optimizes for the success of the whole program.

The State of the World

Principle 1: Discovery is no longer the bottleneck, drug engineering is. Over the past decade, AI and new biology have transformed drug discovery, and will continue doing so. Structure prediction, generative design and high-throughput screening have made finding a molecule with a desired biological effect faster and cheaper than ever. That’s where nearly all the innovation, capital and talent have gone. What comes after has barely changed. A molecule that kills a cancer cell in a well-plate is not a drug. It still has to be engineered to be soluble, stable, safe, permeable and manufacturable, and that stage is a black hole: programs spend 5+ years and tens of millions of dollars there, mostly on manual trial and error. Biotechs run on finite runway and investor timelines, so at some point they stop optimizing and take a compromised molecule into the clinic. Those compromises surface later as toxicity, poor exposure or formulation failures, exactly where failure is most expensive and irreversible. Risk could also occur in clinical trials when it’s no longer traceable to its root causes. The industry got better at finding starting points, but not at turning them into drugs.

Principle 2: Most biotechs don’t and won’t run AI-native. Sophisticated AI-native drug development companies like Isomorphic are creating methods to run this process intelligently and significantly cut the development cycles. Frontier labs are absorbing all the top AI talent. Biotech companies and much of pharma can’t build such AI capabilities and will be left out, running development the old way. That hits the small biotechs hardest. Their value inflects at clinical milestones, and a molecule only reaches them once it’s engineered into a candidate that can enter the clinic and hold up there. Drug engineering decides whether they get there, how fast, and with how much runway left. The firms least able to build AI are the ones that most need this stage to work.

Principle 3: Current AI won’t solve all diseases anytime soon, the next frontier is teaching AI how to run in the real world. Human biology is too complex, too poorly measured and too slow to verify for any current model to capture it. No one who runs drug programs believes otherwise. There will be no model that one-shots a drug from discovery to clinic. The next frontier is AI that understands how objects and actors interact in the real economy, attempting to model the real world of drug development. Such model will answer how a result from a lab propagates across the entire program, influences the experiment to do next, decides the procurement strategy, and changes the sequence of experiments across multiple labs.

Principle 4: China got extremely good at high-throughput scaling, the West can catch up by winning on a different scaling curve. Western biotech companies rely heavily on Chinese suppliers synthesizing large bulks of molecules. The West shouldn’t try to compete with China in this game because it can’t win it. The winning gameplan is to develop the intelligence to synthesize and test 100 molecules intentionally, instead of synthesizing 10,000 and testing them arbitrarily.

The Shape of the Problem

Principle 5: Drug engineering is a search through multiple coupled design spaces, and nothing guides the search. For a drug to work, it has to hit several performance specs at once, and those specs are coupled. Start with the molecule. A one-atom change made to fix solubility also shifts potency, permeability or metabolic stability, often in opposite directions. You can’t optimize one property at a time; you’re searching for a rare point where everything works simultaneously. And the molecule is only the first space. Salt and crystal form, formulation composition and process parameters each open their own, and a choice in one closes options in the next: the structure picked for potency constrains which solid forms are available, which decides what a formulation can do, which decides whether it can be manufactured at scale. Each space is enormous on its own, and they multiply. Against that, a typical program makes and tests a few thousand compounds, each costing weeks of synthesis and expensive assays, chosen largely by expert intuition. Skilled scientists spend years in trial and error, and each round of results only loosely informs the next. Prediction models and LLMs help at the margin, but they’re bolted onto the same loop: they score one property at a time, don’t decide which experiment to run next, and don’t compound as the program generates data. A high-dimensional, coupled, data-scarce search is being run by hand.

Principle 6: The search is cut into stages run years apart, so risk surfaces late, when it’s hardest to fix. Nobody searches those design spaces together. A program runs them in sequence, over years, with a different team owning each one and a handoff in between. Each team optimizes what’s in front of it with the information it has, then passes the molecule on. But the coupling doesn’t respect the handoffs. A change made today to gain potency can be the reason that, three years later, every formulation you try kills that potency. By then cause and effect are separated by years and hundreds of intervening decisions, so nobody can tell which one did the damage. And there is no way back: no model of the whole program on which to replay that decision, test an alternative, or ask what today’s choice will do downstream. Recovery means returning to the bench and redoing months or years of work. Most programs cannot afford that, so they carry the flaw forward. Software engineers can roll back, and aerospace engineers test on a digital twin before touching hardware. Drug programs can do neither.

Principle 7: Every program is its own data distribution, so pretrained models can only ever be a prior. Drug engineering data is made inside live programs: a few thousand compounds, proprietary assays, a handful of scaffolds. What’s public is small, inconsistent between labs, and skewed toward molecules that already worked. The search is local: once a lead is chosen, its core structural features stay largely fixed to preserve potency, so a program explores a narrow but fine-grained space around one structure, and no two programs share a space. Large-scale chemical data factories, and the models trained on them, won’t resolve decisions at this resolution: train on all kinds of molecules and you learn what “roughly drug-like” means, while the decisions that make or break a program hinge on one-atom differences inside one local chemical neighborhood. Those models are useful priors. What the problem demands is a system that learns this program’s chemistry from the few experiments the program can afford.

The Shape of the Solution

Principle 8: Drug engineering needs a decision engine. What matters in a program is not just “what are this molecule’s properties?” It is “given everything we’ve learned and everythig we’re still unsure about, what should we make and test next?” Predictions are uncertain almost everywhere until a molecule reaches the assay. The goal is not to eliminate uncertainty randomly upfront, but to navigate the action space to resolve it well enough to converge. Each batch of experiments should be chosen for what it will teach as well as what it might achieve, so every cycle moves toward the target profile and also sharpens the model where the decision is most sensitive. Past campaigns and pretrained knowledge set the starting priors, and the program’s own data does the steering. A system built this way compounds as the program runs. It needs hundreds of well-chosen molecules where trial and error needs thousands.

Principle 9: A drug program needs a living model of itself. The remedy for sequential, siloed decisions is one evolving model of the whole program: a digital twin. It doesn’t attempt to simulate all biology and chemistry from first principles. Instead, it is the program’s working state: every molecule made, every measurement, the current beliefs about how structure drives properties like potency, ADMET, formulation and manufacturability, and how uncertain each belief is. Every result propagates in both directions. Backward, it tests the hypotheses behind the experiment and revises what the program believes. Forward, it rescores the paths still open and flags where today’s choice is building downstream risk, such as the potency gain that will later fight formulation, while changing course is still cheap. When something breaks, recovery no longer means going back to the bench and backtracking across fragmented teams. The alternatives were mapped all along, and the twin shows which ones still hold.

Principle 10: The objective function is maximizing the probability of technical success. A program is verified in sequence over years: in vitro, in vivo, formulation, manufacturing, clinic. No system can one-shot a candidate and wait five years to learn whether it was right. So the thing to optimize is not how accurately a model scores molecules. It is the likelihood that the program clears every endpoint it will face, how quickly it converges, and how well it recovers when a verification step fails. That changes what gets built. Models should be judged by the decisions they enable, not by benchmark scores. Verification loops at each stage feed one shared state, and the engine keeps narrowing to the few actions that could realistically clear all the endpoints.

Optagon Labs

We are an AI-native R&D company that embeds in the engineering process, executing it autonomously step-by-step. Optagon runs the drug engineering value chain, connecting all endpoints, and optimizing for one core objective: the technical success of the program. Making this happen requires two central elements: embodying the state of the program and controlling its rolled out scenarios with action, and turning predictions into real world execution.

We take a drug program from where it stands to a candidate built to survive the clinic. The customer's scientists stay in the loop throughout. What they gain is a program that learns every cycle and a view of the whole of it: which paths are open, which are closing, and why.

We turn predictions into actions in the real economy. A program moves only as fast as the experiments behind it. We orchestrate execution across the customer's own labs, CROs, CDMOs, robotic cloud labs and in-silico models, matching each experiment to whoever is best placed to run it on cost, speed and quality. Only what is worth testing gets made, and results feed straight back into the program's state with no handoffs in between. Rather than owning benches, we own the loop that connects decisions to them. Execution is becoming a commodity; closing that loop is not, and running it across many programs makes it faster, cheaper and better calibrated every time.

We are building the intelligence to make drug development fast, predictable, and scalable, and to unlock an abundance of medicines.