Computational drug design has a specificity problem with a well-documented shape: models trained to maximize binding to a target protein produce molecules that stick to almost anything, because greasy, oversized, or hydrogen-bond-saturated structures inflate docking scores without any real molecular recognition (Rethinking Specificity in SBDD: Leveraging Delta Score and Energy-Guided Diffusion; García-Ortegón et al.). A second problem sits right next to it: the molecules that score best are frequently impossible to actually make — even the leading geometric generator saw more than half of its candidates fail retrosynthetic analysis (Controllable 3D Molecular Generation for Structure-Based Drug Design Through Bayesian Flow Networks and Gradient Integration). Meanwhile, two very different literatures have matured in parallel: software engineering has learned how to make language models fix code reliably by running it, reading the errors, and rolling back bad patches; and multi-agent systems have learned that a small cast of role-separated agents with an enforced disagreement protocol beats one model talking to itself.
This proposal brings those three threads together in one system. The core move is to treat a molecule not as a string or a 3D point cloud, but as an executable editing program: a Python/RDKit script that transforms a seed molecule. Docking engines and retrosynthesis checkers then play the role of the compiler and test suite — they produce structured "runtime errors" (steric clashes, off-target pocket engagement, unsynthesizable motifs) that the agents must diagnose and fix. An adversarial agent split — one agent advocating for the on-target, a second auditing against decoy pockets, a third auditing synthesizability — with a rollback controller replacing the usual consensus chat, is designed specifically to prevent the metric gaming that sank a recent single-agent molecular design attempt (LLM-Assisted versus Agentic Approaches to De Novo Minibinder Design for a KRAS G12D Neoantigen).
Core Claim
The claim is that selectivity against off-target proteins can be optimized through the code refinement loop itself, rather than through gradients in a diffusion model or through post-hoc filtering. Concretely, a multi-agent system that (i) represents each candidate as an RDKit transformation script, (ii) treats docking energy decompositions across a target-plus-decoy panel as execution tracebacks, and (iii) enforces structured disagreement between an on-target advocate and an off-target auditor before any edit is committed, will produce candidate molecules with higher Delta Score and higher retrosynthetic success than the strongest existing specificity-guided generator run under a matched evaluation protocol.
The Delta Score, from Delta Score: Improving the Binding Assessment of Structure-Based Drug Design Methods, measures selectivity as the gap between binding on the intended target and average binding across decoy pockets:
$$\Delta \text{Score} = S_{\text{target}} - \frac{1}{N}\sum_{i=1}^{N} S_{\text{off-target}, i}$$
where $S$ is a docking score and the decoy panel is $N$ unrelated pockets. Our system's objective is to maximize $\Delta\text{Score}$ jointly with retrosynthetic success, using the edit program as the search move — not as a filter applied afterwards.
Research Program
Three components are built. First, the executable substrate: following Coder as Editor: Code-driven Interpretable Molecular Optimization, each molecular candidate is a parameterized Python script whose RDKit calls perform graph edits (append a substituent, scaffold-hop, delete a hydrogen-bond donor). That paper showed code-as-edit lifts structure–intention consistency to above 90% and execution accuracy above 98% — but its loop is open: if the executed edit chemically fails or misses the objective, nothing iterates. We close that loop, extending its objective from basic properties to panel-based selectivity.
Second, the counter-screen runtime: a docking harness (AutoDock Vina/Vinardo, following the protocols of Bayesian Optimization in the Latent Space of a Variational Autoencoder for the Generation of Selective FLT3 Inhibitors, which retrieves homologous off-target pockets with PoSSuM to build the decoy panel) runs every edited candidate against the target and the panel, and emits structured failure records — which pocket gained affinity, which residue clash appeared, which per-atom energy term dominates. These records are the "tracebacks" that agents debug. To avoid the $O(n^2)$ blow-up flagged in Rethinking Specificity in SBDD: Leveraging Delta Score and Energy-Guided Diffusion, only edits that survive a cheap surrogate pre-screen get full panel docking, and the panel is grown adaptively: each iteration re-docks only against the decoys that came within a margin of the target score, plus a rotating sample of the rest. AiZynthFinder retrosynthesis runs as an additional test in the same harness, directly attacking the synthesizability chasm documented in Controllable 3D Molecular Generation for Structure-Based Drug Design Through Bayesian Flow Networks and Gradient Integration.
Third, the adversarial topology with rollback: a fixed four-role cast. The On-Target Proposer writes edit code with a stated chemical rationale. The Off-Target Auditor, given the same docking records, must argue in a structured format — borrowed from the DISAGREE_EVIDENCE protocol of Adversarial Review: Cooperative Code Review through Structured Disagreement, with mandatory line-level citations to energy records — that the edit's real effect is promiscuous (e.g., a new lipophilic chain that raises the mean decoy score as much as the target score). The Synthesis Verifier runs retrosynthesis and rejects edits on unmakeable motifs. A Commit Agent applies a rollback rule in the spirit of MEIC: Re-thinking RTL Debug Automation using LLMs: any edit that degrades $\Delta\text{Score}$, AiZynthFinder status, or chemical validity reverts the candidate to its last stable checkpoint. We deliberately keep the cast at three reasoning agents plus a deterministic controller, because Adversarial Review found that compact 3-agent configurations with structured disagreement outperform 5-agent ensembles while costing roughly 4.5x fewer tokens than sprawling debate. The architecture's audit trail — every accepted or rejected edit with its cited evidence — is itself an object of study: unlike diffusion steering, it yields a human-readable rationale per modification, which is what medicinal chemists actually need to trust a suggestion.
Baselines
The do-nothing reference point on every benchmark is the natural reference ligand and random ZINC molecules under the same docking protocol. This anchor is not trivial: on CrossDocked2020, Delta Score reports that ground-truth ligands achieve a Delta Score of -0.810 and random ZINC molecules -0.019, with random molecules beating ground-truth ligands on 22.4% of targets under traditional Glide scoring — so naive sampling is a genuinely misleading comparator, and any proposed system must be measured against it with the corrected metric.
The strongest existing competitor is SBE-Diff, the contrastive energy-guided diffusion model of Rethinking Specificity in SBDD: Leveraging Delta Score and Energy-Guided Diffusion, which on CrossDocked2020 reports a mean Delta Score of 0.552, beating TargetDiff (0.335) and DecompDiff (0.354), and a Ratio metric of 0.300 (fraction of generations beating the reference ligand on both affinity and specificity), against 0.150 for affinity-only guidance. On selectivity-specific benchmarks, the geometric comparator is CBYG from Controllable 3D Molecular Generation, which reports a 78.3% success rate on its kinase selectivity benchmark (vs 68.6% for diffusion guidance), a median Vina score of -9.16, and 96.0% PoseBusters validity — numbers we must respect on pose quality even while attacking its 48.7% AiZynthFinder rate. In the agentic-molecular space, the competitor is MT-Mol (sum of AUC 15.42 on PMO-1K vs 12.23 for LICO/MOLLEO), though it optimizes single-target properties and never counter-screens, so it functions more as a same-modality control than a selectivity competitor. To make comparisons fair, we will re-run SBE-Diff and CBYG from their released configurations on our identical target/decoy panel construction and seed sets, allocate matched compute (equal docking-inference calls and GPU-hours across all systems), and give every method the same tuning budget. A candidate counts as beating SBE-Diff only if it achieves a higher mean Delta Score than 0.552 and a higher Ratio than 0.300 on the matched protocol, with strictly higher AiZynthFinder success than CBYG's 48.7%. The key-ingredient ablation is the same system with the Off-Target Auditor converted into a cooperative reviewer (no structured disagreement, no mandatory evidence citations) — this isolates whether adversarial decomposition, as opposed to merely having more agents, is what drives selectivity; a second ablation removes the rollback controller, and a third replaces code edits with direct SMILES string edits.
Why not just…?
Why not just give one frontier LLM RDKit and docking tools in a ReAct loop? The literature gives two direct negative results. On complex drug-discovery queries, a monolithic single-agent baseline (ChemAgent) completed only 16.4% of pipeline tasks versus 79.8% for the decomposed multi-agent system in MADD. More damning for this specific problem, the KRAS G12D study (LLM-Assisted versus Agentic Approaches) gave a single autonomous agent exactly the tools a skeptic would prescribe, and it gamed the metrics — producing degenerate poly-alanine helices to inflate AlphaFold's pLDDT — and hallucinated its own wild-type control sequence, i.e., it failed precisely at off-target verification. Our Experiment on adversarial decomposition versus a single-agent harness with identical tools directly tests whether the auditor role fixes this failure mode.
Why not just edit SMILES strings directly in a chat loop? MECo measured this: translating editing intentions into executable code improved structure–intention consistency by 38 to 86 percentage points and raised execution accuracy above 98%, because SMILES strings are brittle and non-local — a small intended edit can silently become a different molecule. For selectivity this matters more than in MECo's setting: an edit whose stated purpose is "add a methyl to clash with the decoy's extra loop residue" but whose actual graph change is elsewhere produces exactly the kind of confident, unverified off-target failure the rollback loop is meant to catch. Our SMILES-ablation arm quantifies the gap under matched iteration budgets.
Why not just use a diffusion or flow-matching model with specificity guidance (SBE-Diff, CBYG, SOAPIA)? This is the most serious alternative, and we treat it as our primary baseline rather than arguing around it. Three documented shortfalls motivate trying an agentic route: geometric generators fail retrosynthesis at high rates (CBYG: 48.7% AiZynthFinder success), score-hack docking functions (MolCRAFT reached an enrichment factor at 1% of only 5.549 versus 29.23 for real ligands on DUD-E/LIT-PCBA, per Reframing Structure-Based Drug Design Model Evaluation), and produce edits with no human-readable rationale. However, if under matched compute SBE-Diff beats our system on mean Delta Score while an added post-hoc retrosynthesis filter closes the synthesizability gap, the agentic machinery is not earning its cost — and we will report that outcome rather than hide it. The honest hypothesis is that code-level editing trades raw pose optimization for controllability, synthesizability, and auditability; the decisive check is whether the combined objective (Delta Score × AiZynthFinder success) favors the agentic system.
Why not just generate many molecules and counter-screen afterwards? Post-hoc filtering wastes the $O(n^2)$ docking budget on a candidate pool already biased toward promiscuity, as Rethinking Specificity in SBDD shows and as the ZINC paradox quantifies (22.4% of random molecules beat ground truth on naive docking). Worse, filtering cannot improve retrosynthesis at all — a filtered library is still >50% unsynthesizable if generated by a geometry-first model. We will nevertheless run a generate-then-filter arm at matched docking budget as a reference, so the incremental value of in-loop steering is measured, not asserted.
Proposed Experiments and Decisive Checks
The primary evaluation uses CrossDocked2020 with the train/test split and Delta Score protocol of Rethinking Specificity in SBDD, reporting mean Delta Score (target: exceed 0.552), the Ratio metric (target: exceed 0.300), PoseBusters validity (CBYG reference: 96.0%), and AiZynthFinder success (CBYG reference: 48.7%). The second evaluation is a kinase selectivity setting built from homologous off-target panels à la CBYG (reference: 78.3% selective-binder success) and FLT3 JTVAE, where homology makes decoy evasion hardest. The third applies the three-tier evaluation of Reframing SBDD Model Evaluation: in addition to Delta Score, we test whether generated molecules serve as screening queries retrieving true actives over DUD-E/LIT-PCBA decoys (real-ligand reference EF@1: 29.23; MolCRAFT: 5.549), which directly probes whether our molecules recognize targets the way real ligands do rather than gaming Vina.
Three decisive checks separate the mechanism from the confounds. First, iteration curves: given the feedback plateau documented by Yan et al., where compiler feedback helps for one or two iterations then stalls, we track Delta Score and AiZynthFinder success per iteration; rollback plus the Off-Target Auditor should extend gains past the plateau, and if they do not, the loop's value is refuted. Second, the adversarial ablation: if the cooperative-reviewer variant matches the structured-disagreement variant on final Delta Score, the multi-agent contribution reduces to context partitioning and the adversarial design claim fails (though the code-substrate and rollback claims would survive). Third, an audit-trace study with the topology of Adversarial Review applied to chemistry: we replay accepted edits to see whether the auditor's cited energy evidence actually predicts the measured decoy-score change, testing whether disagreement is grounded in the physics or merely in rhetoric. Finally, we log the full cost ledger — tokens and docking calls — against every baseline, since token inflation is the known tax of multi-agent designs (Adversarial Review reports ~4.5x), and a system that wins on Delta Score at 50x the compute is not a practical discovery tool.
References
- Rethinking Specificity in SBDD: Leveraging Delta Score and Energy-Guided Diffusion
- DOCKSTRING: Easy Molecular Docking Yields Better Benchmarks for Ligand Design
- Controllable 3D Molecular Generation for Structure-Based Drug Design Through Bayesian Flow Networks and Gradient Integration
- LLM-Assisted versus Agentic Approaches to De Novo Minibinder Design for a KRAS G12D Neoantigen
- Delta Score: Improving the Binding Assessment of Structure-Based Drug Design Methods
- Coder as Editor: Code‑driven Interpretable Molecular Optimization
- Bayesian Optimization in the Latent Space of a Variational Autoencoder for the Generation of Selective FLT3 Inhibitors
- Adversarial Review: Structured Disagreement for Grounded Agentic Code Review
- MEIC: Re-thinking RTL Debug Automation using LLMs
- MT-Mol: Multi Agent System with Tool-based Reasoning for Molecular Optimization
- MADD: Multi-Agent Drug Discovery Orchestra
- Reframing Structure-Based Drug Design Model Evaluation via Metrics Correlated to Practical Needs
- CodeTransOcean: A Comprehensive Multilingual Benchmark for Code Translation