Target discovery is rarely as simple as finding a single broken gene. For heterogeneous diseases like cancer, the difference between a healthy cell and a diseased one isn’t governed by a single molecule; it is the result of a complex web of cell regulation, epigenetics, environmental or other external signaling mechanisms, and more. What’s more, cells are by their very nature constantly changing, making a high-dimensional space even more complex. To discover effective drug targets, we have to understand this massive, noisy web of biological interactions and the varied contexts in which they operate.
At Clockwork Bio, we’re automating the search for the mechanisms that drive cells to transition into diseased states. In theory, giving a frontier AI model grounding in a biochemical knowledge graph covering these entities and interactions should be a no-brainer…
… and yet.
The idea to leverage knowledge graphs for target discovery and evaluation is hardly novel. Well-publicized industry consortia such as the OpenTargets platform seek to leverage knowledge graph approaches to support target discovery, and many major pharmaceutical companies and biotechs have their internal efforts as well. These projects have certainly borne fruit in many areas (I’ve been part of such projects myself); but, try as I might, I can find no evidence that they have systematically changed the process of making target decisions. When you mention new knowledge graph projects to industry insiders and investors today, the reaction is a well-earned dose of skepticism.
That skepticism is entirely justified, but I believe also misplaced. Given the fast-moving state of the art in agentic AI systems, knowledge graphs can finally become the indispensable engine for target discovery that they should be… but only if we fundamentally re-think how they are built and modeled. Let’s discuss why the old models failed, and how we have re-thought knowledge graphs for the agentic era.
The Anatomy of a Failed Graph: Yesterday’s Architecture Blocks Tomorrow’s AI
While the intent behind legacy knowledge graphs was undoubtedly correct, three aspects of their design and management fundamentally limited their effectiveness as discovery engines. These same three factors are even more limiting in an agentic context.
Curation Inertia
Building a graph is hard; maintaining it is harder. Historically, legacy knowledge graphs were treated as pets, not cattle; a single, monolithic graph was continuously hand-updated to represent new data and new modeling assumptions.
- The Legacy Trap: Biology moves quickly. New data teaches us about new connections every day; but, more starkly, new assays and experimental modalities continuously give us the ability to make measurements within more deeply modeled and understood contexts, and our ontology has to evolve to match. This meant that every change was more expensive than the last, and eventually graphs withered on the vine.
- The Agentic Blocker: If we’re going to trust an agent to decide on experiments (which are, after all, both expensive and time-consuming), we absolutely must be able to audit its decision-making process. But how can we do that when the graph that grounds the agent may have already ‘moved on’?
The Complexity Tradeoff: Human-Readable vs Machine-Actionable
Biology is full of relationships with very different properties and that only occur under very specific conditions (Protein A only interacts with Protein B in Tissue C when exposed to environmental signal D for at least time period E …). Knowledge graphs are fully capable of modeling this complexity, but it increases ontology complexity which, in turn, increases query complexity.
- The Legacy Trap: Legacy graphs were forced into a tradeoff between biological fidelity (usefulness) vs human ability to query (usability). A low-fidelity graph led to bad targets; a high-fidelity graph that nobody can query correctly led to no targets at all.
- The Agentic Blocker: Agents can handle query complexity easily… if they know the ontology. Handing an agent a bare query endpoint requires it to guess at a schema it can’t see. Guessing wrong property names or relationship types leads to empty result sets that the agent silently interprets as a lack of data rather than a bad query. Agents require that graph structure and ontology be embedded directly in their tools.
The Flattened Signal
Legacy graphs flattened uncertainty from many different sources (lab measurement error, NLP confidence, …) into static, scalar “confidence scores” per edge. Disparate signals were rarely aggregated into coherent, overall measures of uncertainty.
- The Legacy Trap: When human biologists traced a highly-scored pathway back to its underlying components and found out that high confidence pathway had one hop that was from a noisy NLP pipeline run over a single abstract, they lost confidence.
- The Agentic Blocker: When we’re choosing the next set of experiments to run, we need to know what will move the needle most by reducing overall uncertainty. Static uncertainty scores – even well-modeled and aggregated ones – don’t give an agent sufficient information to distinguish between confident estimates of likelihood and wild guesses. Agents require every hypothesis to carry calibrated beliefs: distributions, not just scores.
Rethinking the Graph for the Agentic Era
If knowledge graphs are going to power agentic target discovery, we have to stop treating them as singular, hand-curated human reference databases and instead treat them like code: reproducible, compiled artifacts built specifically for machine reasoning.
Here’s how we do that at Clockwork Bio: we didn’t build a knowledge graph; we built a knowledge graph builder.
Compiled, Not Curated
We treat knowledge graphs like interchangeable, compiled tools, rebuilt whenever new data or different modeling assumptions make it worthwhile. A graph is instantiated from a combination of two pinned assets:
- Data Manifest. Named, versioned, immutable data assets that correspond to content-addressed blobs of strongly-typed Avro messages. These faithfully represent upstream data source messages, including upstream quality scores or uncertainty metrics.
- Graph-Builder Code. Versioned code artifacts representing the ontology, how different message types inform it, and the probabilistic modeling methodologies (prior building, updating).
Maintaining compatibility between the two is critical, and depends on two enforcement mechanisms:
- CI Schema Evolution Gates. Commits that break stringent schema evolution rules are not allowed. Breaking changes require creating a new schema, and in turn require maintaining code for handling each kind of message separately.
- Compile-Time Checking. Our graph builder uses native Rust structs and enums generated from our Avro schemas. This means that failure to handle all cases of an enum or union type, failure to handle nullable fields, etc. are all compile-time errors instead of run-time errors or (worse) silent bad behavior.
Critically: this approach means that we can give one agent access to multiple different graphs, unlocking tasks such as comparing different probabilistic assumptions, evaluating the impacts of different data sources, etc. It also delivers on auditability of graph-powered decisions: a graph is perfectly reproducible given its manifest and graph-builder code version.
Agentic from the Ground Up
Every graph instance ships with a Model Context Protocol (MCP) server. The MCP gives the agent specialized tools for querying against the knowledge graph, yes; but, more importantly, it provides searchable, indexed ontology documentation that is designed specifically for agents. This gives us two key benefits over the obvious solution of handing the agent a big stack of documentation:
- Progressive Disclosure. Managing agent context is critical, and handing it a big pile of raw ontology documentation means that the more complicated the ontology, the less free context the agent has to work with it. Instead, we give the agent the ability to discover the documentation that it needs to deal with specific node and edge types, specific domains, or specific types of queries as it goes.
- Multiple ontologies, multiple docs. The documentation is itself a compiled artifact that ships with the graph and the MCP; so, an agent with access to multiple graphs can successfully navigate each and understand the differences between them.
Explicit Uncertainty: Distributions, Not Scores
If our agent is going to choose experiments that provide maximal decrease in uncertainty, then our graph must actually encode that uncertainty. So, one of the most critical pieces of our graph-builder code is the encoding of our hypotheses and our Bayesian belief models about them:
- Discovery Ontology. Encoding of hypotheses and their underlying mechanisms within their appropriate contexts.
- Hypothesis Generation. Graph- and agent-powered enumeration of the space of hypotheses, grounded in the best available biological data and improving as better data becomes available.
- Belief Model. Principled modeling of our beliefs about hypotheses across multiple axes. Are the underlying links true? Are the environmental signals present? Is it sufficient to cause phenotypic shift? Is it necessary?
- Probabilistic Assumptions. How are priors generated? What types of experimental evidence update them, and how?
These beliefs and assumptions are modeled directly in the graph and its agent-documentation as parameterized Bayesian distributions, allowing the agent to reason both about current uncertainty AND about how new experiments will inform that uncertainty.
Earning the Wet-Lab Spend
Agents live and die by their feedback cycles. Tasks like code generation have the luxury of simple, cheap feedback; spend a few seconds compiling, look at some wonderful error messages, and iterate. Biological discovery has no such luxury: real feedback requires wet-lab experiments that cost thousands of dollars, take weeks to run, and return noisy data.
Because our agents cannot rapidly iterate their way to truth, they have to be right before we spend: if not right about what the outcomes of experiments will be, at least right about what we stand to learn.
Our knowledge graph approach isn’t just about building a better data set; it is about fitting out our agents with the necessary harness to finally automate the search for complex mechanisms that drive disease, and we believe it is the strongest route toward realizing the promise of frontier AI in target discovery.