Beyond Static Models: Agentic AI and Multi-Agent Systems in Drug Discovery

Tue, 23 Jun 2026 00:00:00 +0000

For most of the last decade, “AI in drug discovery” effectively meant static prediction: train a model on a curated dataset, feed it molecules, read off a number — a predicted activity, a solubility, a toxicity flag. Useful, but passive. The model never decided what to compute next, never picked up a tool, and never questioned its own output.

That assumption is now out of date. A new class of systems treats the language model not as a predictor but as a reasoning controller — an agent that decomposes a goal, writes and runs code, calls external tools like docking engines and quantum chemistry packages, inspects the results, and revises its own plan. When several such agents collaborate — one proposing strategies, another implementing them, a third critiquing the output like a peer reviewer — you get a multi-agent system, and the workflow starts to resemble an automated research loop rather than a single forward pass.

The core pattern: plan → act (write code, call tools) → observe → critique, then iterate. The Model Context Protocol (MCP) layer is what lets the agent reach real scientific tools and databases.

This post explains what actually changed, the design patterns that make it work, and five open-source projects on GitHub that put these ideas into practice. It closes with the part the hype usually omits: where this breaks down.

What actually changed

Three capabilities, layered on top of ordinary LLMs, do most of the work.

1. Tool use. Instead of answering from parametric memory, the agent emits a structured call to an external tool — run a docking job, compute partial charges, query a database — and feeds the result back into its reasoning. The chemistry is still done by the specialised tool; the LLM orchestrates it.

2. The Model Context Protocol (MCP). is an open standard for exposing tools, data sources, and functions to an LLM through a uniform interface. Before MCP, every integration was bespoke. With it, a docking engine, a UniProt query, or an ADMET predictor can be published once as an MCP server and reused across any MCP-aware agent — which is why several of the projects below ship as MCP servers rather than monolithic apps.

3. Retrieval-augmented generation (RAG). Rather than fine-tuning a model on proprietary chemistry (expensive and quickly stale), the agent retrieves relevant facts from external databases at query time and reasons over them. This grounds outputs in real data and makes provenance auditable — important when a prediction has to survive scrutiny.

Together these turn a frozen model into something that can act, look up ground truth, and correct course.

The design patterns

Most agentic drug-discovery systems are variations on a few recurring architectures. Recognising them makes any new project easier to evaluate.

Planner / executor. One agent operates at a high level of abstraction — laying out a discovery strategy — while a second translates each step into concrete, executable code. Separating “what to do” from “how to do it” keeps the reasoning legible and the code focused.
Multi-agent critique. A generator proposes a hypothesis or molecule; a separate critic agent challenges it, checks it against constraints, and sends it back for revision. The adversarial framing catches errors a single pass would miss.
RAG-grounded reasoning. Agents are wired to authoritative sources so claims are anchored in retrieved evidence rather than generated from memory.
Tool-augmented control. The LLM is a controller over a toolbox — docking, molecular dynamics, QM, property predictors — and contributes orchestration and interpretation, not the underlying physics.

Keep these in mind as a lens for the projects that follow.

Five open-source agents worth examining

The projects below are concrete implementations of the patterns above. They are research-grade and evolve quickly, so verify the repository URL, license, and current status before depending on any of them — links and capabilities drift.

The five projects, coloured by their dominant design pattern.

1. CLADD — Genentech

A multi-agent, RAG-driven framework that connects LLMs to biochemical databases without task-specific fine-tuning. Multiple agents collaborate to contextualise a molecule from retrieved data and produce property estimates such as toxicity and binding affinity, with the retrieval step keeping the reasoning grounded in real records. 🔗

2. AgentD — hoon-ock

An end-to-end agent for molecular design, virtual screening, and SMILES refinement. It folds drug-likeness filters (Lipinski, Veber) directly into the loop and can generate 3D protein–ligand structures via Boltz. It runs as an MCP server, so its capabilities can be plugged into other MCP-aware clients. 🔗

3. DrugAgent — FermiQ

A clean planner/executor split. An “LLM Planner” formulates high-level discovery strategies; an “LLM Instructor” turns each into executable Python — for example, assembling and running an ADMET evaluation. Dividing labour between strategy and implementation keeps both halves auditable. 🔗

4. DEDA — Drug Evaluation and Discovery Agent

A local, MCP-based assistant focused on bioinformatics and molecular pathways — effectively a domain-specialised chat agent. It translates plain-English commands into queries against resources like UniProt and AlphaFold and supports real-time binding-pocket mapping. 🔗

5. Scientific Agent Skills — K-Dense-AI

Less a single agent than a skill library that turns a general LLM (Claude, Gemini, and others) into a scientific operator. It bundles 140+ ready-made skills connecting agents to 70+ scientific databases, spanning tasks from molecular dynamics to genomics to docking. 🔗

The lineage: this didn’t appear from nowhere

It’s worth situating these tools in the prior work that established the paradigm, because the ideas are a few years old even if the MCP packaging is new.

ChemCrow (Bran et al., 2024) coupled an LLM to a suite of expert chemistry tools and showed it could plan and execute synthesis and discovery tasks — an early, influential demonstration that tool-augmented LLMs outperform the bare model on real chemical problems.
Coscientist (Boiko et al., Nature, 2023) used a GPT-4-based agent to autonomously plan and carry out experiments, including driving physical lab hardware — a landmark for closed-loop autonomous experimentation.

The five projects above inherit directly from this lineage; the recent additions are the standardisation (MCP) and the multi-agent collaboration that make such systems easier to assemble and extend.

The caveats the hype skips

Agentic systems are powerful, but they are not a substitute for judgment, and treating them as one is how pipelines produce confident nonsense.

Hallucination still happens — now with tools. Grounding reduces fabrication but doesn’t eliminate it. An agent can call the right tool with the wrong arguments, or misinterpret a correct result. Outputs need validation, not trust.
The physics lives in the tools, not the LLM. A docking score is only as good as the docking engine and its setup. The agent’s reasoning cannot rescue a poorly prepared receptor or bad charges (a recurring theme — see the ).
Reproducibility is hard. Non-deterministic LLM behaviour makes runs difficult to reproduce exactly. Pin model versions, log every tool call and its inputs, and treat agent transcripts as part of the experimental record.
Cost and latency add up. Multi-agent loops with critique steps can issue many model calls per task; this matters at virtual-screening scale.
Research-grade maturity. Most of these repositories are young and fast-moving. Check the license, the test coverage, and how actively the project is maintained before building on it.

The right framing is augmentation: these agents are excellent at orchestrating tedious multi-tool workflows, drafting analysis code, and surfacing candidates — while the scientist sets the question, validates the chemistry, and owns the conclusions.

Takeaway

The shift from static models to agentic, tool-using systems is real and substantive: with MCP for standardised tool access, RAG for grounding, and multi-agent collaboration for planning and self-critique, AI is moving from answering questions to running workflows. The five open-source projects here are a good entry point for seeing how that looks in practice — clone one, read how it wires the LLM to its tools, and you’ll understand the pattern far better than any summary can convey. Just keep the validation discipline of a computational chemist: the agent accelerates the work, but you still answer for the result.

Agents | Yassir Boulaamane