arXiv:2604.09308v1 [cs.AI] 10 Apr 2026
Constraint-Aware Corrective Memory for Language-Based Drug Discovery Agents Maochen Sun
Youzhi Zhang∗
Gaofeng Meng∗
Institute of Automation, Chinese Academy of Sciences China School of Advanced Interdisciplinary Sciences, University of Chinese Academy of Sciences China [email protected]
Centre for Artificial Intelligence and Robotics, Hong Kong Institute of Science & Innovation, Chinese Academy of Sciences China [email protected]
Institute of Automation, Chinese Academy of Sciences China Centre for Artificial Intelligence and Robotics, Hong Kong Institute of Science & Innovation, Chinese Academy of Sciences China [email protected]
Abstract
1
Large language models are making autonomous drug discovery agents increasingly feasible, but reliable success in this setting is not determined by any single action or molecule. It is determined by whether the final returned set jointly satisfies protocol-level requirements such as set size, diversity, binding quality, and developability. This creates a fundamental control problem: the agent plans step by step, while task validity is decided at the level of the whole candidate set. Existing language-based drug discovery systems therefore tend to rely on long raw history and underspecified self-reflection, making failure localization imprecise and planner-facing agent states increasingly noisy. We present CACM (Constraint-Aware Corrective Memory), a language-based drug discovery framework built around precise set-level diagnosis and a concise memory write-back mechanism. CACM introduces protocol auditing and a grounded diagnostician, which jointly analyze multimodal evidence spanning task requirements, pocket context, and candidate-set evidence to localize protocol violations, generate actionable remediation hints, and bias the next action toward the most relevant correction. To keep planning context compact, CACM organizes memory into static, dynamic, and corrective channels and compresses them before write-back, thereby preserving persistent task information while exposing only the most decision-relevant failures. Our experimental results show that CACM improves the target-level success rate by 36.4% over the state-of-the-art baseline. The results show that reliable language-based drug discovery benefits not only from more powerful molecular tools, but also from more precise diagnosis and more economical agent states.
Drug discovery is a long, expensive, and highly iterative search process over an enormous chemical space [5]. A large body of computational work has therefore sought to accelerate key stages of this pipeline, including structure-based molecular generation, lead optimization, docking, and virtual screening [18, 21, 27, 28, 33, 34]. More recently, deep generative approaches have substantially expanded the design space of structure-based drug discovery, moving from autoregressive and graph-based methods toward diffusionbased 3D molecular generation and pocket-conditioned lead design [1, 8, 13–15, 22, 31]. These advances have made it increasingly realistic to build closed-loop systems that can propose, refine, and evaluate candidate molecules rather than execute only one isolated computational subroutine. In parallel, large language models (LLMs) have progressed from static text generators to tool-using agents that can plan, invoke external modules, inspect intermediate feedback, and revise subsequent actions [30, 35–37]. This shift has quickly reached the scientific domain. Recent work has explored AI agents for biomedical discovery at large [10], autonomous chemistry and experiment design [6, 29], chemistry tool-use systems [7, 25], and domain-specific assistants for molecular or biological workflows [11, 17, 39, 41]. As a result, language-based drug discovery is no longer limited to text-only reasoning: an LLM can now function as a planner that coordinates molecular generation, optimization, screening, and evaluation inside an iterative decision loop [2, 26]. However, reliable success in this setting is fundamentally a setlevel problem. A drug discovery episode does not succeed merely because one step improves docking or because a few molecules appear promising. It succeeds only when the returned set jointly satisfies a protocol over size, diversity, binding quality, and developability. In our setting, this protocol is operationalized through metrics such as Quantitative Estimate of Drug-likeness (QED), synthetic accessibility, Lipinski-style drug-likeness constraints, docking-based affinity proxies, novelty, and diversity [4, 9, 23, 34]. This means that locally reasonable actions can still fail globally: an agent may over-optimize one property while collapsing diversity, retain too few valid candidates after screening, or return a compact pool that still violates the overall protocol.
CCS Concepts • Computing methodologies → Machine learning; Model development and analysis; • Applied computing → Life and medical sciences.
Keywords drug discovery agents, corrective memory, multimodal verification, language-based scientific agents, protein–ligand docking, agent reliability ∗ Corresponding authors.
1
Introduction
This mismatch creates a control problem that current languagebased pipelines still handle imprecisely. Existing systems often leave failure interpretation to the planner itself, which must infer from a long accumulated trajectory what went wrong, which requirement is currently violated, and which action should come next. In generic agent settings, self-correction is often expressed as free-form reflection, iterative rewriting, or tool-interactive critique [12, 24, 32]. Yet in drug discovery, the corrective signal must be more specific: it should be grounded simultaneously in the task requirements, the protein-pocket context, and the current candidate-set evidence. Otherwise, the planner receives feedback that is semantically plausible but operationally weak. A second problem lies in inefficient management of agent states. Here, agent states denote the planner-facing memory written back across iterations, including task requirements, current pool summaries, action trajectories, screening outcomes, and failure feedback. Throughout the paper, we use agent states and planner-facing memory interchangeably for these written-back contexts. As the agent proceeds through multiple iterations, this state accumulates heterogeneous information: persistent task inputs, transient pool statistics, action trajectories, screening outcomes, and prior failures. Generic agent research has shown that memory organization is central to long-horizon performance [20, 35, 38], but this issue becomes particularly acute in drug discovery because the agent must reason over a compact context while satisfying a multi-constraint molecular protocol. If static requirements, intermediate pool statistics, and obsolete failure records are all written back in the same way, the planner’s context becomes long, noisy, and increasingly difficult to use effectively. This paper argues that reliable language-based drug discovery requires both precision and parsimony. Precision means converting set-level failure into an explicit, protocol-grounded diagnosis rather than leaving the planner to infer it implicitly. Parsimony means writing back only the most decision-relevant state, so that the planner receives compact agent states instead of long raw history. To this end, we propose CACM, a framework that reorganizes the closed loop around two components: a Protocol Audit followed by a Grounded Diagnoser, and a structured Compress & Write Back mechanism over static, dynamic, and corrective memory. The audit checks whether the current candidate set satisfies the task protocol. When it does not, the diagnoser jointly analyzes requirement cues, pocket context, and candidate-set evidence to localize the failure, generate a repair hint, and recommend an action bias for the next step. The resulting signal is then compressed and written back into compact agent states. Our contributions are threefold. First, we formulate the key bottleneck of language-based drug discovery as a set-level control problem. Second, we introduce CACM, which couples Protocol Audit and Grounded Diagnoser with structured static, dynamic, and corrective memory plus compressed write-back mechanism. Third, our experimental results show that CACM improves the target-level success rate by 36.4% over the state-of-the-art baseline, showing that more reliable drug discovery agents depend not only on stronger molecular tools, but also on more precise and more economical control signals.
2 Related Work 2.1 Language-Based Scientific Agents Tool-augmented LLM agents have recently shown strong promise across scientific discovery settings [10, 29, 35]. Existing examples include autonomous chemistry and experiment planning [6], chemistry tool-use systems such as ChemCrow and CACTUS [7, 25], multi-omic analysis agents [41], protein-design agents [11], de novo molecule-design assistants [17], drug-repurposing or reasoningoriented agents [16], and more recent modular drug-discovery agents that span multiple in silico subtasks [26]. These works demonstrate that LLMs can coordinate tools, interpret intermediate results, and support multi-step scientific workflows rather than merely answer one-shot prompts. That said, these systems are not all solving the same problem. Some focus on automated experimentation or chemistry assistance; some operate in omics or protein-design settings; and some emphasize chat-based molecule-design interfaces or repurposingoriented search. Our task is narrower and more specific: closed-loop, structure-based de novo small-molecule discovery from a proteinpocket input, with success defined by whether the final returned set satisfies a protocol over multiple medicinal-chemistry and docking criteria. Among existing language-based systems, the closest task-aligned reference is LIDDiA, because it exposes a comparable planner–tool loop and provides a public benchmark with compatible inputs, tools, and target-level evaluation. The key difference is that LIDDiA mainly relies on the planner’s own trajectory interpretation and goal-checking logic, whereas our method introduces an explicit protocol-aware control layer with deterministic returnedset auditing, failure-localized diagnosis, and a compact plannerfacing memory interface. We therefore compare directly against LIDDiA as the strongest task-aligned baseline, while positioning our method as a control-layer improvement to planner-guided drugdiscovery agents rather than a narrow modification to one specific planner implementation.
2.2
AI for Structure-Based Molecular Design and Optimization
Recent progress in structure-based de novo design has been driven by both classical search methods and modern generative models [33]. Earlier lines of work include fragment-based or atom-based pocket construction and search-based optimization, while more recent approaches increasingly rely on neural generators that condition directly on protein-pocket structure [18, 21]. Representative generative SBDD methods include LiGAN for receptor-conditioned 3D generation [28], Pocket2Mol for efficient sampling in protein pockets [27], and a growing family of diffusion-based approaches such as TargetDiff, DecompDiff, D3FG, DiffSBDD, and related models [13, 14, 22, 31]. Recent developments have further expanded this line toward dual-purpose generation-and-optimization frameworks, shape-conditioned binding-molecule generation, AlphaFoldinformed conditioning, and latent-conditioned structure-based diffusion [3, 8, 15, 19]. Reviews on diffusion-based molecular design now highlight both their power and their remaining limitations for reliable 3D generation and downstream drug-design use [1]. 2
These methods have significantly improved the quality of candidate proposal and refinement, but they mainly operate at the level of proposal or local optimization. They do not decide when a system should generate new candidates, when it should optimize an existing pool, when it should screen or merge candidate sets, how to diagnose failure of a returned set against a task protocol, or how to maintain compact agent states across multiple iterations. Our framework is therefore complementary to these molecular tools. Rather than replacing them, we treat them as executors inside a higher-level closed loop that reasons over candidate sets, protocol satisfaction, and corrective control.
functional channels and compresses them into compact agent states for the next decision (Sec. 3.3).
3.1
Problem Setup
We follow the returned-set design task of LIDDiA [2]. For a target protein, the input consists of a receptor pocket 𝑃 and a naturallanguage requirement set describing the desired properties of the final returned molecule pool. We denote this requirement set by 𝑅 = {𝑟 𝑗 }𝑚 𝑗=1 , where each requirement is normalized into a structured tuple 𝑟 𝑗 = (𝑓 𝑗 , 𝛼 𝑗 , ⊲⊳ 𝑗 , 𝑏 𝑗 ).
2.3
Reasoning, Reflection, and Memory in LLM Agents
(2)
Here 𝑓 𝑗 denotes the target metric, 𝛼 𝑗 denotes the corresponding set-level aggregation operator, ⊲⊳ 𝑗 is the comparison operator, and 𝑏 𝑗 is the threshold. Typical examples include cardinality for pool size, a pool-level diversity functional for diversity, and worst-case min/max aggregation for molecule-level properties such as QED, SAScore, Lipinski, novelty, and docking score. At iteration 𝑘, the planner chooses one action
General LLM-agent research has studied tool use, planning, critique, and multi-agent coordination through frameworks such as Toolformer, ReAct, Reflexion, Self-Refine, CRITIC, AutoGen, and Language Agent Tree Search [12, 24, 30, 32, 36, 37, 40]. These methods establish the broader agentic paradigm in which language models act in iterative loops, inspect feedback, and revise their behavior. At the same time, recent surveys have highlighted memory as a central design dimension in long-horizon agents, including how information should be stored, retrieved, compressed, and written back [35, 38]. Retrieval-augmented generation and explicit nonparametric memory also provide a broader conceptual basis for grounding language models beyond purely parametric context [20]. However, most generic agent frameworks are task-agnostic and rely on free-form reflection or broad retrieval signals. Drug discovery imposes a more constrained requirement: the agent must satisfy a fixed protocol over an evolving set of molecules while operating under limited context. Our method therefore emphasizes two properties that remain underexplored in generic agent work for this setting: precision, namely protocol-grounded diagnosis tied to requirements, pocket context, and candidate-set evidence; and parsimony, namely structured compression of static, dynamic, and corrective memory before write-back. Rather than adding open-ended reflection alone, we convert verification outcomes into compact control signals that are directly actionable in the next planning step.
3
(1)
𝑎 (𝑘 ) = (𝜏 (𝑘 ) , 𝑢 (𝑘 ) ),
(3)
where 𝜏 (𝑘 )
∈ {Generate, Optimize, Code/Screen} is the action type and 𝑢 (𝑘 ) is its input. Executing 𝑎 (𝑘 ) yields a candidate molecule set 𝑆 (𝑘 ) together with pool statistics and molecule-level property summaries for control. The task is defined at the returned-set level: a run is successful only when the final returned pool jointly satisfies the protocol, rather than merely containing a few individually strong molecules. We therefore define the set-level observation for requirement 𝑟 𝑗 as 𝑜 𝑗 𝑆 (𝑘 ) = 𝛼 𝑗 𝑓 𝑗 , 𝑆 (𝑘 ) , (4) which induces a deterministic acceptance gate 𝑔 𝑆 (𝑘 ) , 𝑅 = 1 ⇐⇒ ∀𝑗, 𝑜 𝑗 𝑆 (𝑘 ) ⊲⊳ 𝑗 𝑏 𝑗 . (5) Otherwise, 𝑔 𝑆 (𝑘 ) , 𝑅 = 0. That is, the gate returns 1 exactly when all requirement-specific observations satisfy their corresponding thresholds; otherwise the returned set is rejected. Rather than planning directly from raw history, CACM condie (𝑘 ) : tions the planner on an adapted agent state 𝑀 e (𝑘 ) , 𝑎 (𝑘+1) = P 𝑀 (6)
Method
The central challenge in our setting is not merely to retain more trajectory content, but to expose agent states that are both precise and parsimonious. The planner must reason over heterogeneous signals, including the returned-set protocol, the receptor-pocket context, summaries of the current candidate pool, and feedback from previous failures. However, these signals are naturally scattered across raw logs, tool outputs, and free-form interaction traces. Directly appending them to memory leads to two coupled problems: the planner receives imprecise decision cues because protocol status and failure causes are not made explicit, and the context length grows rapidly with the number of iterations. As illustrated in Fig. 1, CACM addresses these issues through two corresponding components. For precision, it makes returned-set failure explicit through deterministic auditing and grounded diagnosis (Sec. 3.2). For parsimony, it reorganizes heterogeneous write-back signals into
where P (·) denotes the planner. Equation (3) defines the action taken at the current iteration, whereas Eq. (6) defines how the next action is chosen after the current result has been evaluated and summarized into the next agent state. The workflow of CACM is as follows: Given a target pocket and a requirement set, the planner first selects one action from Generate, Optimize, and Code/Screen. The molecular toolchain executes this action and produces a candidate molecule set. CACM then checks whether the current set already satisfies the returned-set protocol. If it does, the run terminates and returns the current set. Otherwise, CACM converts the failure into an explicit diagnosis signal, writes this signal back together with the task and search context, and exposes the resulting compact agent state to the planner for the next decision. The role of CACM is therefore not to replace the 3
Memory Static
Dynamic
Agent States
Update
Set-level Diagnosis
Action Pocket
Planner
Generate
Corrective
Compress & Write Back
Candidate Set
Grounded Diagnoser O N
Optimize
O N
C
C
C
O
C O
C
Screen
C
Fail Protocol Audit
Pass
Final Set
Requirements
Figure 1: Overview of constraint-aware corrective memory (CACM). CACM maintains an agent state composed of static memory, dynamic descriptive memory, and corrective memory. The planner selects one action from Generate, Optimize, and Code/Screen. The executed action produces a candidate molecule set, which is checked by a deterministic protocol audit. If the current set satisfies the returned-set protocol, it is returned as the final output. Otherwise, the audited result is reorganized into corrective memory, compressed, and adapted into the next agent state. CACM therefore turns raw history into a compact protocol-aware agent state. where 𝐷 (·) denotes the grounded diagnosis operator. Its inputs are the pocket 𝑃, the requirement set 𝑅, the current candidate set 𝑆 (𝑘 ) , and the residual vector Δ (𝑘 ) . The output 𝑧 (𝑘 ) is a compact corrective record for write-back. Importantly, 𝐷 (·) is not an abstract black-box reflection operator. It is grounded by the deterministic audit and by the current set evidence. Given the violated requirements and their residuals, it identifies which requirements remain unsatisfied, determines the dominant failure type, and produces a short repair hint together with a recommended next-action bias. In this way, CACM turns returned-set failure into an explicit and actionable diagnosis signal, rather than leaving the planner to infer the dominant problem from long raw history alone.
molecular tools, but to control how protocol-relevant information is diagnosed, organized, and written back across iterations.
3.2
Set-Level Diagnosis
This subsection addresses the precision side of CACM by making returned-set failure explicit through deterministic auditing and grounded diagnosis under a fixed protocol. CACM first applies a deterministic protocol audit to the current pool. This component is entirely code-based and serves as the source of truth for hard pass/fail decisions at the returned-set level. For each requirement 𝑟 𝑗 , we compute a signed residual (𝑘 ) − 𝑏 , 𝑜 𝑆 if ⊲⊳ 𝑗 ∈ {≥, >}, 𝑗 𝑗 ) Δ (𝑘 = (7) 𝑗 (𝑘 ) , if ⊲⊳ 𝑗 ∈ {≤, <}, 𝑏 𝑗 − 𝑜 𝑗 𝑆 and collect these values into (𝑘 ) Δ (𝑘 ) = Δ1(𝑘 ) , . . . , Δ𝑚 . (8)
3.3
Concise Memory Construction
This subsection addresses the parsimony side of CACM by organizing, compressing, and writing back only the most decision-relevant information at each iteration. A binary fail signal is not sufficient for the next decision. The planner also needs to know what the task requires, what the current search state looks like, and why the previous step did not yet satisfy the protocol. CACM therefore organizes write-back information through three memory channels:
Under this convention, negative residuals correspond to violated constraints, while their magnitudes quantify the distance to protocol satisfaction for the current pool. This audit has two roles. First, it determines whether the current pool already satisfies Eq. (5). Second, when the pool still fails, it provides a structured failure description that can be used for corrective write-back. CACM therefore does not rely on an unconstrained language judgment to decide whether a returned set is valid. CACM then converts the audited failure state into an explicit corrective record through a grounded diagnoser: 𝑧 (𝑘 ) = 𝐷 𝑃, 𝑅, 𝑆 (𝑘 ) , Δ (𝑘 ) , (9)
𝑀 (𝑘 ) = 𝑀𝑠 , 𝑀𝑑(𝑘 ) , 𝑀𝑐(𝑘 ) ,
(10)
where 𝑀𝑠 is static memory, 𝑀𝑑(𝑘 ) is dynamic descriptive memory, and 𝑀𝑐(𝑘 ) is corrective memory. 4
Static memory. Static memory stores target-specific information that remains invariant throughout the trajectory: 𝑀𝑠 = Φ𝑠 (𝑃, 𝑅),
The retained channel contents are then compressed separately: 𝑀˜ 𝑥(𝑘 ) = C𝑥 𝑀¯ 𝑥(𝑘 ) , 𝑥 ∈ {𝑠, 𝑑, 𝑐}, (15)
(11)
where C𝑥 (·) denotes a channel-specific compression operator. Here C𝑥 (·) is a deterministic formatter rather than a learned summarizer: each channel is rendered into a fixed template. Static compression summarizes the target and pocket context; dynamic compression summarizes the retained pool states and recent actions; corrective compression summarizes the retained failure records together with the repair direction and next-action bias. Finally, the compressed channels are adapted into the agent state e (𝑘 ) = A 𝑀˜ 𝑠(𝑘 ) , 𝑀˜ (𝑘 ) , 𝑀˜ 𝑐(𝑘 ) , 𝑀 (16) 𝑑
where Φ𝑠 (·) denotes the static-memory constructor. Given the pocket 𝑃 and the requirement set 𝑅, it builds a deterministic target description including the target identity, the requirement set, the pocket file, and a compact pocket summary extracted from the receptor structure. In our system, this pocket summary is computed from lightweight structural descriptors, including pocket size, residue composition, geometric extent, and coarse physicochemical ratios. Static memory therefore provides a stable description of what must ultimately be achieved and what receptor environment is being optimized against.
where A (·) denotes the adaptation operator. The operator A (·) assembles the labeled channel summaries into a unified agent state. The resulting state therefore remains compact and predictable across iterations, while still preserving the task context, the current search frontier, and the most relevant corrective signal for the next decision step.
Dynamic descriptive memory. Dynamic descriptive memory stores a compact view of the evolving search state: 𝑀𝑑(𝑘 ) = T 𝑀𝑑(𝑘 −1) , 𝑆b(𝑘 ) , 𝐻𝑎(𝑘 ) , (12) where T (·) denotes the dynamic-memory update operator, 𝑆b(𝑘 ) denotes the retained summary of the current pool, and 𝐻𝑎(𝑘 ) denotes a short recent-action window. Rather than appending the full raw history, CACM keeps only informative pool summaries and a short action history. Concretely, 𝑆b(𝑘 ) is constructed by combining a recency cue with a deterministic quality heuristic so that the retained pool remains informative for control, rather than merely logging all previous candidates. 𝐻𝑎(𝑘 ) records only the most recent decisions and their outcomes, making the current search frontier readable without exposing the planner to the full raw history.
3.4
Protocol-Aware Closed-Loop Control
CACM therefore operates as a protocol-aware closed loop. At ite (𝑘 −1) and selects the next action eration 𝑘, the planner reads 𝑀 via Eq. (6). The molecular toolchain executes this action and produces a candidate set 𝑆 (𝑘 ) . The deterministic protocol audit then evaluates the returned-set status through Eq. (5) and computes the residual vector Δ (𝑘 ) . If the current pool satisfies the protocol, the run terminates under the configured stopping logic. Otherwise, the grounded diagnoser converts the audited failure into a corrective record, the memory channels are updated and compressed, and the next planning step proceeds from the resulting compact agent state. Within this loop, the planner and the grounded diagnoser have distinct roles. The planner determines which action to execute next, while the grounded diagnoser determines why the current pool still fails and which repair direction should be prioritized. CACM thus couples deterministic protocol checking, failure-localized diagnosis, and concise memory write-back into a unified control loop for returned-set optimization across iterations.
Corrective memory. Corrective memory stores failure-localized control information and is updated only when the current pool fails Eq. (5) at that step: 𝑀𝑐(𝑘 ) = U 𝑀𝑐(𝑘 −1) , 𝑧 (𝑘 ) , (13) where U (·) denotes the corrective-memory update operator, and 𝑧 (𝑘 ) is the corrective record produced by the grounded diagnoser in Eq. (9). This channel stores the explicitly diagnosed reason for failure and the corresponding repair direction, rather than a freeform history of all past failures. Explicit memory organization alone is not sufficient. If all historical pool summaries and all diagnostic records are retained indefinitely, the planner input quickly becomes redundant, unstable, and difficult to control. CACM therefore introduces a selection– compression–adaptation pipeline that turns the three memory channels into a compact agent state. For each channel 𝑥 ∈ {𝑠, 𝑑, 𝑐}, CACM first applies channel-wise selection before formatting: 𝑀¯ 𝑥(𝑘 ) = Sel𝑥 𝑀𝑥(𝑘 ) , 𝑥 ∈ {𝑠, 𝑑, 𝑐}, (14)
4 Experiments 4.1 Experimental Setup Benchmark and agent setting. We evaluate on the same 30-target benchmark introduced by LIDDiA [2]. Each target provides a curated protein pocket, a natural-language design requirement, and known drugs used to derive target-specific reference thresholds. For all agentic methods, we keep the original action space, namely Generate, Optimize, and Code/Screen, with the same maximum of 10 iterations per target. Unless otherwise specified, the DeepSeekbased LIDDiA baseline and all CACM variants use deepseekreasoner as the controller model. The molecular toolchain is unchanged: Pocket2Mol is used for structure-based generation [27], GraphGA for molecular optimization [18], and AutoDock Vina for docking-based binding evaluation [34].
where Sel𝑥 (·) denotes the channel-specific selection operator. For the static channel, selection is trivial because the target-level context remains fixed across iterations. For the dynamic channel, Sel𝑑 (·) retains the most informative pool summaries together with a short recent-action window. For the corrective channel, Sel𝑐 (·) keeps high-value corrective records rather than the full diagnosis history.
Baselines. Following LIDDiA [2], we compare against two taskspecific molecular design baselines and four general-purpose LLM 5
baselines. Pocket2Mol is a structure-based generator that uses the target pocket as input, whereas DiffSMOL is a ligand-based generative model that requires a binding ligand. For general-purpose LLMs, we include Claude, GPT-4o, o1-mini, and o1. In Table 1, the first six columns are taken directly from the original LIDDiA paper, while the last two columns report our DeepSeek-based LIDDiA reproduction and CACM under the same benchmark and molecular tool setting.
to extract useful guidance from intermediate failures instead of saturating after the first few actions. For the LIDDiA baseline and CACM columns, %m/t and #m/t denote target-wise averages over the returned pools, and the returnedpool summary medians in the lower part of Table 1 report per-target medians parsed from the logs. Appendix C lists the exact terminal molecule sets for all 30 targets from the same logs used to produce Table 1. We move these molecule strings out of the main body because the per-target SMILES are too long to present clearly within the space limit.
Evaluation metrics. Following LIDDiA, we report molecule-level quality using drug-likeness (QED) [4], Lipinski compliance (LRF) [23], synthetic accessibility (SAS) [9], docking score (VNA) [34], novelty (NVT), and set diversity (DVS). A molecule is counted as highquality (HQ) for a target if it satisfies the same target-specific quality thresholds used in LIDDiA, i.e., it is at least as good as the corresponding known-drug reference on QED, LRF, and docking, no worse on SAS, and also satisfies NVT ≥ 0.8. At the target level, we follow the returned-set evaluation protocol of LIDDiA. Specifically, we report the same target-level indicators as in LIDDiA: DVS > 0.8, 𝑁 ≥5 & DVS, 𝑁 ≥5 & HQ, DVS & HQ, and TSR (target success rate). Here, TSR denotes the percentage of targets whose returned sets satisfy the LIDDiA returned-set success conditions. All target-level indicators are computed using the same definitions and target-specific thresholds as in LIDDiA.
4.2
Returned-pool molecule quality. The returned-pool summary medians in the lower part of Table 1 show that several baselines remain competitive on individual molecule-level statistics. DiffSMOL reaches the highest novelty median (0.89), Claude gives the highest QED median (0.78), several methods reach the top LRF median (4.00), and o1-mini obtains the best SAS median (2.02). Even the reproduced DeepSeek-based LIDDiA baseline remains reasonably strong on these pooled summaries, with medians of 0.84 for NVT, 0.69 for QED, 3.93 for LRF, 2.67 for SAS, and −7.15 for VNA. CACM improves some of these rows only moderately, for example from 0.69 to 0.72 on QED and from −7.15 to −7.17 on VNA. This apparent gap between a large TSR improvement and only modest pooled-median gains is expected. These rows summarize individual-molecule properties inside the returned pools, and a baseline can score well here because a few particularly strong molecules pull up one metric or one average, even when the returned set as a whole still fails the TSR protocol. The issue is therefore not whether some molecules are good, but whether the final set jointly satisfies all returned-set conditions at the same time. CACM’s main advantage is that it converts comparable molecule-level quality into much stronger set-level reliability, rather than merely maximizing one property in isolation.
Main Results
Returned-set performance. Table 1 reports the main comparison on the 30-target benchmark. Among the first six baselines, Pocket2Mol and DiffSMOL both achieve perfect diversity coverage at the target level, with 100.0% on DVS > 0.8 and on 𝑁 ≥5 & DVS, but their final returned sets satisfy the full TSR condition on only 23.3% (7/30) and 0.0% (0/30) of targets, respectively. The four general-purpose LLM baselines perform even worse on TSR: Claude and GPT-4o each reach only 6.7% (2/30), while o1-mini and o1 both remain at 0.0% (0/30), although some still obtain nontrivial DVS & HQ scores, such as 33.3% (10/30) for GPT-4o and o1-mini. These results suggest that isolated returned-set indicators can look acceptable while the full protocol is still not satisfied. Against this background, CACM substantially improves targetlevel success over the reproduced DeepSeek-based LIDDiA baseline: TSR increases from 73.3% (22/30) to 100.0% (30/30). The same trend appears in the returned-set indicators: DVS & HQ rises from 80.0% (24/30) to 100.0% (30/30), and 𝑁 ≥5 & DVS rises from 83.3% (25/30) to 100.0% (30/30). Meanwhile, CACM returns much smaller terminal sets: the average final pool size drops from 21.0 molecules to exactly 5.0. This shows that the gain does not come from keeping larger pools until termination, but from returning compact sets that already satisfy the target-level protocol, indicating better stopping quality rather than greater search breadth. The trajectory view points to the same conclusion. Appendix D reports the cutoff results at 2/4/6/8/10 iterations. The contrast is sharp: the LIDDiA baseline already reaches 90.9% of its eventual successes by iteration 2 (20/22), indicating a strongly front-loaded search, whereas CACM gains another 40.0 percentage points after iteration 2 and reaches full TSR by iteration 8. This suggests that CACM not only improves the endpoint, but also keeps the search productive when early local refinement is insufficient, continuing
4.3
Ablation Study
Table 2 analyzes which components are responsible for the gain of CACM. We progressively remove key components in the corrective control loop and examine how returned-set quality changes under the same evaluation protocol. We first consider the lightest retained variant, Set-level Repair Signal, which keeps grounded repair feedback but does not write corrective information back into memory. This variant improves over the LIDDiA baseline from 73.3% (22/30) to 86.7% (26/30) TSR, with DVS & HQ rising from 80.0% (24/30) to 86.7% (26/30), while the average returned pool size drops from 21.0 to 6.7. This shows that the repair signal is highly effective: making the current failure state explicitly legible to the planner already yields a large gain. We next examine the role of precision in corrective write-back. When corrective memory is constructed but corrective selection is removed, TSR drops from 86.7% (26/30) to 83.3% (25/30), DVS & HQ decreases by the same amount, and the average returned pool size increases from 6.7 to 8.0. This shows that writing back more corrective information is not necessarily better. Without explicitly selecting the most decision-relevant corrective entries, excessive failure information can become noise and interfere with planning. This variant still outperforms the LIDDiA baseline, indicating that 6
Table 1: Main results on the 30-target LIDDiA benchmark. Numbers for Pocket2Mol, DiffSMOL, Claude, GPT-4o, o1-mini, and o1 are taken from the original LIDDiA paper; the last two columns are recomputed from our logs. Pocket2Mol %m/t #m/t or %t or #t
DiffSMOL %m/t #m/t or %t or #t
Claude GPT-4o o1-mini o1 LIDDiA (DeepSeek) CACM (ours) %m/t #m/t %m/t #m/t %m/t #m/t %m/t #m/t %m/t #m/t %m/t #m/t or %t or #t or %t or #t or %t or #t or %t or #t or %t or #t or %t or #t
Generated molecules Generated – 100.0 100.0 100.0 Valid QED ≥ QED𝑡 53.4 53.4 99.7 99.7 LRF ≥ LRF𝑡 SAS ≤ SAS𝑡 77.4 77.4 VNA ≤ VNA𝑡 15.3 15.3 NVT ≥ 0.8 87.6 87.6 HQ 6.4 6.4
– 99.9 60.0 72.1 7.5 24.7 98.2 0.7
100.0 99.9 60.0 72.1 7.5 24.7 98.2 0.7
– 98.7 96.7 98.7 92.7 63.3 46.9 30.3
5.0 4.9 4.8 4.9 4.6 3.2 2.4 1.5
– 97.3 88.2 95.9 90.7 59.2 68.3 35.0
5.0 4.9 4.4 4.8 4.5 3.0 3.4 1.7
– 91.3 90.1 90.7 81.4 47.9 64.1 28.2
5.0 4.6 4.5 4.5 4.1 2.3 3.2 1.4
– 95.3 88.3 95.3 92.6 34.6 55.9 20.7
5.0 4.8 4.4 4.8 4.6 1.8 2.8 1.0
– 100.0 96.6 97.0 93.5 97.3 97.0 88.8
21.0 21.0 20.2 20.2 19.7 20.6 20.3 18.7
– 100.0 100.0 100.0 100.0 100.0 100.0 100.0
5.0 5.0 5.0 5.0 5.0 5.0 5.0 5.0
Among all targets DVS > 0.8 100.0 𝑁 ≥5 & DVS 100.0 𝑁 ≥5 & HQ 27.7 DVS & HQ 23.3 TSR 23.3
100.0 100.0 3.3 10.0 0.0
30 30 1 3 0
30.0 27.7 23.3 10.0 6.7
9 8 7 3 2
90.0 77.7 10.0 33.3 6.7
27 23 3 10 2
67.7 43.3 0.0 33.3 0.0
20 13 0 10 0
70.0 57.7 3.3 20.0 0.0
21 17 1 6 0
86.7 83.3 76.7 80.0 73.3
26 25 23 24 22
100.0 100.0 100.0 100.0 100.0
30 30 30 30 30
Metric
30 30 8 7 7
Returned-pool summary medians
Metric
Pocket2Mol DiffSMOL Claude GPT-4o o1-mini
NVT ↑ QED ↑ LRF ↑ SAS ↓ VNA ↓ DVS ↑
0.87 0.51 4.00 2.46 -4.74 0.88
0.77 0.78 4.00 2.30 -6.69 0.76
0.89 0.55 3.43 6.15 -4.23 0.89
0.82 0.74 3.99 2.16 -6.56 0.84
0.79 0.75 3.85 2.02 -6.31 0.79
o1 0.80 0.77 4.00 2.03 -5.97 0.80
LIDDiA (DeepSeek) CACM (ours) 0.84 0.69 3.93 2.67 -7.15 0.81
0.85 0.72 4.00 2.65 -7.17 0.89
Table 2: Ablation study of CACM. TSR is computed under the same LIDDiA success definition for all variants. DVS & HQ is computed from the returned pool. Avg. Term. Iters is averaged over 30 targets.
Variant LIDDiA baseline Set-level Repair Signal CACM w/o Corrective Selection CACM w/o Dynamic Compression CACM
Repair Signal
Structured Memory
Dynamic Compression
Corrective Selection
TSR (% / #)
DVS & HQ (% / #)
Avg. Pool Size
Avg. Term. Iters
✗ ✓
✗ ✗
✗ ✗
✗ ✗
73.3 / 22 86.7 / 26
80.0 / 24 86.7 / 26
21.0 6.7
4.40 4.07
✓
✓
✓
✗
83.3 / 25
83.3 / 25
8.0
4.27
✓
✓
✗
✓
96.7 / 29
96.7 / 29
8.6
3.40
✓
✓
✓
✓
100.0 / 30
100.0 / 30
5.0
3.07
constructing an explicit corrective channel is itself useful, even if unfiltered write-back is suboptimal. We then study the contribution of refinement in the descriptive state. Removing dynamic compression keeps target-level success relatively strong, with TSR remaining at 96.7% (29/30), but enlarges the returned pool from 5.0 to 8.6 molecules. DVS & HQ also drops from 100.0% (30/30) to 96.7% (29/30), while the average termination iterations increase from 3.07 to 3.40. This indicates that dynamic compression is not merely a token-saving device: by distilling raw
history into a more compact agent state, it keeps the planner-facing context more focused. Finally, the full CACM model is the only variant that simultaneously achieves perfect TSR (100.0%, 30/30), perfect deterministic DVS & HQ (100.0%, 30/30), the smallest returned pools (5.0), and the fewest termination iterations (3.07). Taken together, the ablations support a coherent picture: set-level repair signals make failures legible, corrective selection makes write-back precise, and dynamic compression makes the agent state compact and decision-ready. 7
Baseline CACM
5000
target from 33,518.3 to 23,042.2, a 31.3% decrease, and reduces wallclock time per target from 45.49 to 43.91 minutes, a 3.5% decrease. This reduction is enabled by earlier successful stopping: the average cutoff iteration drops from 4.40 to 3.07, a 30.2% decrease. At the same time, CACM does not make each step trivially cheaper: controller-side token cost per iteration remains close to the LIDDiA baseline (7,945.6 vs. 7,448.5), while per-iteration runtime is higher because of the extra diagnosis call (15.14 vs. 10.11 minutes). The trajectory-level reduction therefore comes from reaching success in fewer iterations, not from weakening the control process. This is also consistent with the KIT snapshots in Appendix E. CACM writes back explicit task requirements, selected pools, recent actions, and corrective guidance as organized planner-facing fields, whereas the LIDDiA baseline exposes a longer appended stream in which old failures, threshold restatements, and local reasoning remain interleaved. The benefit of CACM is therefore not only shorter memory growth, but also more structured and decisionrelevant planner-facing agent states. This property becomes more important in harder settings. The current benchmark is short-horizon, so the benefit of structured memory is only partially exposed. For harder targets, stricter protocols, or longer action horizons, unstructured history would continue to grow with the trajectory, increasing token cost and weakening control quality. CACM keeps the planner-facing agent state compact, organized, and protocol-focused as the horizon grows.
Memory chars
4000 3000 2000 1000 1
2
3
4
5
6
Iteration
7
8
9
10
Figure 2: Planner-facing memory length across iterations. Average planner-facing memory length over iterations on the 30-target benchmark, comparing the LIDDiA-style rawhistory write-back with the CACM compressed agent state. Only when these components are combined does the corrective loop become both reliable and efficient.
4.4
Memory Compression
Beyond target-level success, we examine how CACM changes the growth of planner-facing agent states. This matters because CACM does not simply add diagnosis; it rewrites planner context through structured static, dynamic, and corrective channels. The effect should therefore be assessed not only by final TSR, but also by how the planner-facing agent states evolve over the trajectory. Figure 2 plots the average planner-facing state length over active targets on the 30-target benchmark. We compare the LIDDiA-style growing raw-history write-back, which keeps appending trajectory text over iterations, with the CACM compressed agent state, which maintains an organized and compact agent state throughout the search process. Representative KIT snapshots are shown in Appendix E, while the success-truncated controller-side token and runtime statistics are reported in Appendix F and Appendix G for the corresponding runs in the same evaluation setting. CACM is not designed to minimize context at the earliest iterations. As Figure 2 shows, it is already longer than the LIDDiA baseline in the first few steps, because it allocates context to protocol-relevant state, diagnosis, and repair guidance. The key difference is not initial length, but subsequent growth. The LIDDiA raw-history write-back grows almost monotonically with trajectory length, whereas CACM quickly enters a compact band. Around iteration 5, the two become comparable in size, after which the LIDDiA baseline continues to expand while CACM remains nearly flat. The advantage of CACM is thus controlled context growth that preserves task-relevant evidence while preventing planner context from drifting into accumulated raw history over time. This difference matters for both efficiency and reliability in practice. A longer free-form history increases prompt cost and exposes the planner to stale or weakly relevant information, whereas CACM preserves a compact agent state centered on protocol-relevant content. The same pattern appears in end-to-end cost. Under successtruncated accounting, CACM reduces controller-side tokens per
4.5
Case Study: How Corrective Memory Changes Control on KIT
We next examine KIT as a concrete case study of how corrective memory changes control. This target is informative because the system already produces nontrivial candidate pools, yet still fails the returned-set protocol. Appendix E shows the corresponding planner-facing snapshots. In the CACM snapshot, the retained pools already satisfy the diversity side of the task, with values of 0.859 and 0.878, while the worst-case docking value still remains around −7.358 against the required threshold of −7.77 for this returned pool. The dominant bottleneck is therefore not diversity, but binding: the pool already has enough spread, but still lacks a sufficiently strong binding tail to fully satisfy the set-level criterion at this point. The contrast with the LIDDiA baseline is structural. The baseline exposes an appended raw-history stream that mixes Generate, Code, and Optimize traces with repeated local judgments, but it does not rewrite the current evidence into an explicit summary of the main protocol gap. CACM instead writes back a selected corrective entry that localizes a binding bottleneck and recommends a targeted Code-based repair over the existing pool. This case clarifies the mechanism of CACM. The gain does not come from writing back more text, but from writing back the right state: task requirements, pocket summary, selected pools, recent actions, and a compressed corrective signal. For KIT, that difference changes planning from open-ended trial-and-error into targeted repair of the dominant bottleneck. 8
5
Table 3: Summary of the main metrics used in the deterministic audit.
Conclusion
We presented CACM, a protocol-aware framework for languagebased drug discovery agents. Rather than changing the molecular generators, CACM improves how the agent interprets search state, diagnoses returned-set violations, and writes compact corrective signals into memory for planning. By organizing multimodal evidence from task requirements, pocket context, and candidate-set evidence into concise agent states, CACM makes diagnosis more explicit and actions more targeted. On the 30-target LIDDiA benchmark [2], CACM improves TSR and the deterministic validity of returned molecule sets, while also reducing trajectory length and final pool size. These results suggest that reliable returned-set optimization remains a missing ingredient in drug discovery agents, and that compact corrective memory provides an effective way to connect auditing, diagnosis, and planning.
Metric
Aggregation
Ref.
Pool size Diversity Novelty QED SAS Lipinski check Docking
|𝑆 | set-level diversity functional set-level novelty functional min𝑥 ∈𝑆 QED(𝑥) max𝑥 ∈𝑆 SAS(𝑥) worst-case pool aggregation max𝑥 ∈𝑆 Dock(𝑥)
benchmark benchmark benchmark [4] [9] [23] [34]
For upper-bounded molecule-level properties, the audit uses worst-case upper-bound aggregation. For synthetic accessibility, 𝑜 SAS (𝑆) = max SAS(𝑥), 𝑥 ∈𝑆
A
Metric Definitions and Audit Details
so that the returned set is counted as valid only when its hardest-tosynthesize molecule still satisfies the bound. Synthetic accessibility is computed using the standard SA score of Ertl and Schuffenhauer [9]. For Lipinski-style rule-based drug-likeness constraints, we follow the standard criteria summarized by Lipinski et al. [23]. When a lower-bound requirement is imposed on the number of satisfied rules or a derived compliance score, the returned-set audit again uses worst-case aggregation over the candidate pool. For docking, lower scores indicate stronger predicted binding. Therefore, when the protocol requires docking quality to be better than a threshold, the audit uses the worst docking score in the returned pool, 𝑜 Dock (𝑆) = max Dock(𝑥), (22)
This appendix specifies the metric definitions and deterministic audit procedure used in CACM. Our main text defines each requirement as 𝑟 𝑗 = (𝑓 𝑗 , 𝛼 𝑗 , ⊲⊳ 𝑗 , 𝑏 𝑗 ), where 𝑓 𝑗 is the metric field, 𝛼 𝑗 is the corresponding set-level aggregation operator, ⊲⊳ 𝑗 is the comparison operator, and 𝑏 𝑗 is the threshold. Given a candidate molecule set 𝑆 = {𝑥𝑖 }𝑛𝑖=1,
(17)
the audit computes the observation 𝑜 𝑗 (𝑆) = 𝛼 𝑗 (𝑓 𝑗 , 𝑆)
(18)
for each requirement and then applies the deterministic validity test defined in the main paper. In CACM, the audit is performed at the returned-set level. This means that the final decision is made on the whole returned pool rather than on isolated individual molecules. When a requirement is inherently set-level, the aggregation is applied directly to the pool. When a requirement is defined at the molecule level, we use a worst-case set-level aggregation so that the returned pool is counted as valid only if all required molecules satisfy the corresponding constraint.
𝑥 ∈𝑆
and compares it against the required upper bound. Docking is performed using the same AutoDock Vina-based pipeline adopted in our experimental workflow [34]. Residual-based failure localization. Given the observation vector, CACM further computes the residual vector Δ (𝑘 ) defined in the main paper. These residuals are not used to replace the hard protocol decision; instead, they serve as an explicit failure-localization signal. Negative residuals indicate unmet constraints, and larger magnitudes indicate larger protocol gaps. This residual vector is then used by the diagnosis stage to construct the corrective record used to update corrective memory.
Pool-level metrics. For pool size, the aggregation is simply the set cardinality, 𝑁 (𝑆) = |𝑆 |. (19) For diversity and novelty, we use the same benchmark implementation as the original evaluation pipeline [2] to ensure direct comparability across methods. In the audit, these quantities are treated as set-level observations and compared directly against the required thresholds.
Why deterministic audit matters. The purpose of this audit is to ensure that returned-set validity is determined by a transparent and reproducible procedure rather than by free-form language judgment. This is particularly important in our setting because the task objective is defined over the entire returned set. A few individually strong molecules are not sufficient if the final pool still violates cardinality, diversity, novelty, docking, or developability constraints. All returned-set results that we recompute from saved trajectories in this paper are evaluated with this unified deterministic audit.
Molecule-level property constraints. For lower-bounded moleculelevel properties, the audit uses worst-case lower-bound aggregation. For example, if all returned molecules are required to satisfy a QED threshold, the corresponding observation is 𝑜 QED (𝑆) = min QED(𝑥), 𝑥 ∈𝑆
(21)
(20)
B
so that the returned set passes only when its weakest molecule still satisfies the threshold. QED follows the standard definition of Bickerton et al. [4].
Implementation Details of CACM
This appendix maps the abstract memory operators in Section 3.3 of the main paper to the concrete implementation used in our 9
Table 4: Implementation-side budget variables used to instantiate bounded selection and compression in CACM. Symbol
Meaning
𝐾𝑑
Maximum number of selected pool summaries retained in dynamic descriptive memory. Maximum number of retained recent actions in dynamic descriptive memory. Maximum number of selected corrective entries retained in corrective memory. Character budget for static memory after deterministic template formatting. Character budget for dynamic descriptive memory after deterministic template formatting. Character budget for corrective memory after deterministic template formatting.
𝑊𝑑 𝐾𝑐 𝐵𝑠 𝐵𝑑 𝐵𝑐
Table 5: Default implementation-side budgets used in CACM. These values are fixed across the full 30-target benchmark without target-specific tuning. Variable
Value
𝐾𝑑 𝑊𝑑 𝐾𝑐 𝐵𝑠 𝐵𝑑 𝐵𝑐
4 3 3 1400 1800 1200
recent actions are exposed to the planner. Second, the selected dynamic content is rendered into a fixed template and then bounded by the dynamic-memory budget 𝐵𝑑 . The selected pool summaries are chosen deterministically rather than by free-form summarization. Concretely, CACM ranks candidate pool summaries using normalized set-level indicators that are already available in the control loop, including pool size, diversity, novelty, QED, Lipinski, docking score, and SAS. The purpose of this ranking is not to redefine the task objective, but to keep the planner-facing dynamic descriptive memory centered on the most decision-relevant pool evidence.
experiments, and then reports an additional sensitivity study for the implementation-side budgets that realize bounded selection and compression in CACM. Because the main paper describes CACM at the level of memory channels and operators rather than software limits, we first make the implementation-side budget variables explicit here. At the implementation level, CACM uses two kinds of budgets. Count budgets limit how many entries can be preserved before channel-wise formatting. Character budgets limit the rendered length of each memory channel after deterministic template formatting. In other words, the implementation introduces bounded memory control at the channel level: static memory is bounded by 𝐵𝑠 , dynamic descriptive memory is bounded by 𝐵𝑑 , and corrective memory is bounded by 𝐵𝑐 . Table 4 summarizes the symbols used in this section.
Corrective memory. Corrective memory stores failure-localized control information produced by the grounded diagnoser, including the dominant failure pattern, unmet constraints, concise rationale, repair hint, and next-action bias. In implementation, only a bounded number of selected corrective entries are preserved in the plannerfacing channel, controlled by the corrective budget 𝐾𝑐 . These entries are prioritized deterministically using violation severity together with recency, so that the corrective channel emphasizes the most decision-relevant unresolved failures rather than the full history of past diagnoses. The selected corrective content is then rendered into a fixed template and bounded by the corrective-memory budget 𝐵𝑐 .
Why channel-wise budgets are needed. The main paper describes CACM as a structured memory mechanism with static, dynamic descriptive, and corrective channels, but it does not spell out how these channels are bounded in software. Without explicit channel-wise budgets, the planner-facing agent state would again drift toward unstructured growth: dynamic descriptive memory could keep accumulating pool summaries and action traces, while corrective memory could keep accumulating past diagnoses even after they are no longer the most decision-relevant signals. The budgets above therefore serve a simple implementation purpose: they turn the abstract selection and compression operators in the main paper into concrete bounded controls for each channel.
Final adaptation. After bounded selection and channel-wise formatting, CACM concatenates the labeled static, dynamic descriptive, and corrective channels into a unified planner-facing agent state. No additional global budget variable is introduced at this stage. In practice, compactness is achieved by controlling each channel separately through 𝐵𝑠 , 𝐵𝑑 , and 𝐵𝑐 , together with the entry-selection budgets 𝐾𝑑 , 𝑊𝑑 , and 𝐾𝑐 . Deterministic formatting. The channel-compression functions used in CACM are deterministic template-based formatters followed by truncation under the budgets above. No learned summarizer is introduced at this stage. The implementation-side budgets therefore instantiate the bounded selection and compression operators in the main paper, rather than replacing them with a different learned module.
Static memory. Static memory stores target-specific information that does not change across the trajectory, including the target identity, the normalized requirement set, the pocket file, and a compact pocket summary derived from the receptor structure. Because this channel is trajectory-invariant, its selection step is trivial in implementation. The retained static content is rendered into a fixed template and then bounded by the static-memory budget 𝐵𝑠 .
Default configuration. In the default configuration, CACM uses 𝐾𝑑 = 4, 𝑊𝑑 = 3, and 𝐾𝑐 = 3 for bounded selection, together with 𝐵𝑠 = 1400, 𝐵𝑑 = 1800, and 𝐵𝑐 = 1200 for channel-wise formatting. These values are chosen once at the implementation level and then kept fixed across the full 30-target benchmark, without targetspecific tuning.
Dynamic descriptive memory. Dynamic descriptive memory stores the evolving search state. In implementation, this channel is bounded in two stages. First, selection is controlled by a dynamic-pool budget 𝐾𝑑 and a recent-action window 𝑊𝑑 . The former limits how many selected pool summaries are retained; the latter limits how many 10
Table 6: Budget configurations used in the CACM sensitivity study. Setting default tight_chars compact_counts wide_counts rebalanced_chars
(𝐾𝑑 ,𝑊𝑑 , 𝐾𝑐 ) (4, 3, 3) (4, 3, 3) (2, 2, 2) (6, 5, 5) (4, 3, 3)
Table 7: Sensitivity of CACM to implementation-side budgets on the 30-target benchmark.
(𝐵𝑠 , 𝐵𝑑 , 𝐵𝑐 ) (1400, 1800, 1200) (900, 1200, 700) (1400, 1800, 1200) (1400, 1800, 1200) (1000, 2200, 1000)
Setting
TSR (% / #)
Avg. Pool Size
Avg. Term. Iters
Avg. State Chars
default tight_chars compact_counts wide_counts rebalanced_chars
100.0 / 30 96.7 / 29 96.7 / 29 100.0 / 30 96.7 / 29
5.00 8.17 8.90 5.53 8.17
3.07 3.47 3.50 3.17 3.43
1572.2 1318.0 1613.4 1580.0 1498.4
Table 8: Channel-wise average lengths of the planner-facing agent state in the CACM sensitivity study. Values are averaged over planner-facing states within each trajectory.
Sensitivity protocol. To test whether the reported CACM performance depends on a narrow implementation-side choice, we ran an additional five-setting sweep around the default configuration. All runs in this section use the same 30-target benchmark, the same controller and molecular toolchain, the same maximum of 10 iterations per target, and the same TSR definition as in the main text; only the implementation-side budgets are changed. Starting from the default configuration, we construct four nearby variants. Two variants perturb the character budgets. tight_chars compresses all three memory channels. rebalanced_chars reallocates more space to dynamic descriptive memory and less space to static and corrective memory. Two variants perturb the count budgets. compact_counts reduces (𝐾𝑑 ,𝑊𝑑 , 𝐾𝑐 ) from (4, 3, 3) to (2, 2, 2), while wide_counts increases them to (6, 5, 5). This sweep is intended as a local robustness check around the default implementation rather than an exhaustive global hyperparameter search.
Setting
Static
Dynamic
Corrective
default tight_chars compact_counts wide_counts rebalanced_chars
601.2 601.2 601.2 601.2 601.2
241.2 264.8 233.0 256.9 262.8
729.8 451.9 779.3 721.9 634.4
Per-target stability. The setting-level averages are supported by a simple per-target stability check. Across the 30 benchmark targets, 28 targets remain successful under all five budget settings. Only two targets ever flip across the sweep: DRD2 fails only under compact_counts, while PTGS1/COX1 fails under tight_chars and rebalanced_chars but succeeds under the other three settings. This means that the observed sensitivity is concentrated on a very small number of harder targets rather than spread broadly across the benchmark. Importantly, these misses are not failed jobs or debugging artifacts: the corresponding runs complete normally and simply reach the iteration cap without achieving a successful stopping point under the same returned-set protocol used in the main text.
Sensitivity results. Table 7 reports TSR together with average final pool size, average termination iterations, and average plannerfacing agent-state length. Table 8 further decomposes the average agent-state length into the static, dynamic descriptive, and corrective channels. Three observations are most relevant. First, the default configuration is not an isolated success point. In addition to the default setting, wide_counts also reaches 100.0% TSR (30/30), with very similar termination behavior and plannerfacing agent-state length. Second, the more aggressive settings remain close to the default rather than collapsing. tight_chars, compact_counts, and rebalanced_chars each still reach 96.7% TSR (29/30). Third, the sweep suggests that the retained-entry budgets are somewhat more consequential than mild character reallocation. In particular, compact_counts is the only setting whose average planner-facing agent-state length becomes slightly longer than the default (1613.4 vs. 1572.2 characters) while also increasing the average final pool size to 8.90. By contrast, tight_chars reduces the average planner-facing agent-state length by 16.2% (1572.2 → 1318.0 characters) yet still preserves 29/30 target successes. Taken together, these results support a moderate stability claim: the reported CACM gains do not depend on a narrowly chosen single configuration, and nearby alternatives recover either identical target-level performance or only a one-target drop on the 30-target benchmark. At the same time, the sweep also shows that overly aggressive compression can slightly weaken performance on a small number of harder targets. We therefore interpret the default budgets as reasonably robust implementation-side controls rather than as arbitrary constants with no effect. 11
C
All Returned Molecules for the 30 Targets
To remove ambiguity about what is actually returned by CACM, this appendix lists the exact terminal molecule set for each of the 30 targets. The molecules reported here are extracted from the same saved trajectories used to compute Table 1 in the main paper, using the same returned-pool selection rule as the main-text audit. Table 9: Terminal molecules returned by CACM for all 30 targets. Each row corresponds to one target and lists the five molecules in the final returned set. Target
Returned molecules
ADRB1
1. Cn1ccc(-c2cc(C(=O)N3CCN(Cc4ccccn4)CC3)c3ccccc3n2)n1 2. O=C(/C=C/c1ccccc1[N+](=O)[O-])Nc1cccc(Cl)c1 3. Cc1nc(C)c([C@H](C)NC(=O)CCC(=O)c2ccc(Cl)cc2)s1 4. COC(=O)N1CC[C@@H](NC(=O)Nc2cnn(-c3ccccc3F)c2)C1 5. CCn1c(CC[C@@H](C)C=O)nc2ccccc21
ADRB2
1. O=C(CCn1cnc2ccccc2c1=O)OCc1ccc(-c2ccccc2)cc1 2. CC1(c2ccc(OS(=O)(=O)c3ccc(Cl)cc3)cc2)SCCS1 3. Cc1occc1[C@H](Cl)Cc1c(F)cccc1F 4. Cc1ccc(C(=O)N[C@H]2CCC(=O)NC2=O)c(N)c1 5. Cc1cc(C(=O)N2CCN(Cc3ccsc3)CC2)no1
AR/NR3C4
1. Cc1ccc(C[C@H](C)NC(=O)Nc2ccccc2CC(=O)N(C)C)c(C)c1 2. Fc1cccc(F)c1N[C@@H]1CCOC2(CCCC2)C1 3. Cn1c(Cl)cnc1C[S@](=O)CCCc1ccc(Cl)cc1 4. CCc1nc(N2CCOCC2)c2onc(-c3ccc(C)cc3)c2n1 5. O=C(NCCOc1ccc(Br)cc1)[C@H]1CCS(=O)(=O)C1
BCHE
1. O=C(NCC(=O)N1CCOc2ccccc21)NC1CCCCC1 2. Cc1ccc(S(=O)(=O)C[C@H](O)COc2ccc(F)cc2Cl)cc1 3. Cc1sc(NC(=O)c2ccon2)nc1-c1ccc2c(c1)CCC2 4. CNC(=O)c1c(C)cccc1NC(=O)Cc1cccc(OCC#N)c1 5. O=S(=O)(NCCCn1cncn1)c1cc(Cl)cc(Cl)c1
CDK5
1. COc1ccc(N2C[C@@H](C(=O)N3CCc4ccccc4C3)CC2=O)cc1 2. N#Cc1ccc(-c2cc(F)cc(C(=O)[O-])c2)cc1O 3. COc1cc(C)c(-c2nc(C3CCCCC3)no2)cc1OC 4. CSc1ccc(Cl)c(C(=O)Nc2cc(C(=O)N(C)C)ccc2Cl)c1 5. C[C@@H](NC(=O)c1cc(=O)c2ccccc2o1)c1cccc(-n2cccn2)c1
CHK2
1. Cc1ccc(NS(=O)(=O)c2cc(C(=O)Nc3ccccc3C(=O)[O-])ccc2Br)cc1 2. c1ccc(SCc2noc(-c3ccco3)n2)nc1 3. O=C(c1ccc(OCC2CC2)nc1)N1CCc2[nH]c(=O)sc2C1 4. COc1cc(Br)c(/C=C2\SC(=N)NC2=O)cc1OC 5. COc1ccc(CCNC(=O)[C@H]2CC(=O)N(c3cccc(C(F)(F)F)c3)C2)cc1
CYP3A4
1. Cc1ccc([C@@H](C)C(=O)N2CCC[C@H](Cn3nnc4c(O)nc(C)nc43)C2)cc1 2. O=C(N/N=C/C=C\c1cccc([N+](=O)[O-])c1)C(O)(c1ccccc1)c1ccccc1 3. Clc1cc(I)c(OCc2nc(-c3ccco3)no2)c2ncccc12 4. O=C1C[C@@H](c2ccccc2)[C@@H](c2ccc(Cl)cc2)C(=O)N1 5. COCCNC(=O)c1ccc2c(c1)[C@H]1C=CC[C@H]1[C@@H](c1ccc(O)c(OC)c1)N2
CYP3A5
1. Cc1ccc2cc([C@@H](c3nnnn3C[C@@H]3CCCO3)N3CCN(Cc4ccccc4)CC3)c(=O)[nH]c2c1 2. O=C(Nc1cccc(-c2cnc3ccccc3n2)c1)c1ccc([N+](=O)[O-])cc1 3. O=C1CC2(CCCCC2)[C@@H](c2ccc(F)cc2)C(=O)N1 4. CCc1ccc([C@H](C)NC(=O)NCc2ccc([S@](C)=O)cc2)cc1 5. c1csc(Cn2ccnc2-c2ccnc3ccccc23)c1
DRD2
1. Cc1ccc(N2C[C@H](C(=O)Nc3ccc(C(C)(C)C)cc3)CC2=O)cc1C 2. CC(C)[C@@H](NC(=O)CCc1ccccc1Cl)c1nc2ccccc2[nH]1 3. CC(=O)N(C)c1ccc(NCc2coc3ccccc23)cc1 4. Cc1ccccc1[C@H](CO)Cc1ccc(Cl)c(Cl)c1 5. Cc1cccc(O[C@H](C)CNC(=O)C(=O)Nc2cccnc2Cl)c1
12
Target
Returned molecules
DRD3
1. Cc1csc(C(C)(C)NC(=O)Nc2ccc(F)cc2OCC2CC2)n1 2. CC[C@H](O)c1nc2ccccc2n1CC(C)C 3. Cc1cc(C)cc(-n2ccn(CC(N)=O)c(=O)c2=O)c1 4. Cc1ccc([C@H](NCCc2nnc(-c3ccccc3)o2)C2CC2)cc1 5. O=C(Nc1ccc(-n2cccn2)cc1)c1nc[nH]n1
EGFR
1. O=C([O-])c1cc(Cl)cc(Cl)c1NC(=S)NC(=O)c1cccc2ccccc12 2. CCc1ccc(-c2n[nH]c(SCc3cc(=O)n4ccsc4n3)n2)cc1 3. O=C1C[C@H](NS(=O)(=O)c2ccc3c(c2)OCCO3)CN1c1ccc2c(c1)OCCO2 4. O=C(c1ccc(F)cc1)N1CCC[C@@H](OCc2cc(F)cc(F)c2)C1 5. CC(=O)N1CCc2cc(S(=O)(=O)[C@@H](C)CC(=O)N3CCN(c4ccccc4)CC3)ccc21
EZH2
1. Cc1c2c(cc3c1O/C(=C\c1c(F)cccc1Cl)C3=O)CN(CCCN1CCOCC1)CO2 2. C[C@@H](Sc1nccn1-c1ccc(Br)cc1)c1nc(N)nc(N(C)C)n1 3. COc1ccc(C)cc1NC(=O)C(=O)N[C@@H](c1ncc(C)s1)C1CC1 4. NS(=O)(=O)c1ccc(NC(=O)CCCSc2ccccc2)cc1 5. CCC[C@@H](C)Nc1nc2cc([N+](=O)[O-])ccc2[nH]1
FLT3
1. Cc1ccc(CCNC(=O)c2csc3c2CC[C@H](C)C3)cc1 2. c1cc(-c2nc(C3CC3)no2)c2cc[nH]c2c1 3. Cc1ccc(-n2cc(-c3cn(Cc4ccoc4)nn3)cn2)cc1C 4. O=C(N[C@H]1CC(=O)N(CC(F)(F)F)C1)[C@H](O)c1ccccc1 5. O=C(NC[C@@H]1COCCO1)c1nnn(-c2ccccc2F)c1-c1ccccn1
GCK/HK4
1. CN(C[C@@H](O)c1ccccc1)C(=O)C1CCN(c2cccc3c2C(=O)N(Cc2ccncc2)C3=O)CC1 2. Cc1ccc(C(=O)NCCNC(=O)Cc2ccc(F)c(F)c2)cc1F 3. CC(C)Cc1nc(CN2CCc3onc(-c4ccc(Cl)cc4)c3C2)no1 4. O=C(Nc1nnc(-c2ccco2)o1)[C@H]1CCCN1S(=O)(=O)c1ccc(F)cc1 5. COc1ccc(OC)c(-c2cc(C(=O)NC[C@]3(O)CCOc4ccccc43)n(C)n2)c1
GLP1R
1. CCN(CC)C(=O)c1cc(C2=CCC(O)(c3ccccn3)CC2)nc2cc(C)ccc12 2. O=c1oc2ccccc2n1C[C@H](c1cccc(C(F)(F)F)c1)C1CC1 3. O=C1C[C@H](C(=O)Nc2ccc(Oc3ccccc3)cc2)NC(N2CCc3ccccc3C2)=N1 4. CC[C@@H](c1nc2c3c(C)c(C)n(-c4ccc(F)cc4)c3ncn2n1)N1C(=O)c2ccccc2C1=O 5. CC1C=CC=C(S(=O)(=O)Nc2ccccc2C(=O)Nc2ccc(F)cc2F)C1
HRAS
1. Cc1ccccc1C(=O)N1CCC(c2nc(O)c3nnn(Cc4ccccc4F)c3n2)CC1 2. CC(C)c1cnn2c(Cl)cc(-c3ccc(Cl)cc3)nc12 3. O=C(/C=C/c1ccc2c(c1)OCO2)Nc1ccc(S(=O)(=O)Nc2nccs2)cc1 4. CC[C@H](NC(=O)CNC(=O)c1cccc(C)c1)C(=O)OC 5. CN(C)c1nc(N)nc(CN(C)S(=O)(=O)c2ccc(F)cc2)n1
HTR2A
1. CCCCn1c([C@H](C)NC(=O)c2ccccc2C)nc2ccccc21 2. N#Cc1cccc(NC(=O)c2cc3c(s2)CCCC3)c1 3. O=S(=O)(NCCc1ccn(-c2ccccc2)n1)c1ccccc1 4. Cc1cccc(Nc2ccc(S(=O)(=O)N(C(C)C)C(C)C)cn2)c1 5. C=CC(=O)Nc1ccc(-c2nc3cc(NC(=O)C=C)ccc3o2)cc1
KEAP1
1. Cc1csc(-c2ccc(C(=O)Nc3cc(C(C)C)on3)cc2)n1 2. O=S(=O)(c1cccnc1)N1CCC(c2ccc(F)cc2)CC1 3. CC(C)(C)c1ncc2c(n1)CN(c1cc(N3CCOCC3)ncn1)C2 4. CCOc1ccccc1/C=C/C(=O)Nc1ccc(N2CCCCC2)cc1 5. CC1(C)OC(=O)[C@@H](c2ccccc2)O1
KIT
1. Cc1ccc(C2CCC(NCc3cccc(CC(=O)NC4CC4)c3)CC2)cc1 2. Fc1ccc2c(c1)CCN(c1ccc(Cl)cc1)C2 3. Cn1cc(NC(=O)C(=O)c2ccc3nncn3c2)ccc1=O 4. Cc1nc(-c2ccccc2)ccc1-c1ccc(F)cc1 5. O=C1CCc2c(OCc3cccc([N+](=O)[O-])c3)cccc21
13
Target
Returned molecules
KRAS
1. Cc1ccc(S(=O)(=O)N2CCCCC2)cc1NC(=O)[C@@H]1CC(=O)N(c2ccc3c(c2)OCCO3)C1 2. C[C@@H](Cc1cccc(C(F)(F)F)c1)C(=O)N(C)c1ccccn1 3. CC[C@@H]1CCCC[C@H]1OCc1cnc(NN)s1 4. O=C(CN1C(=O)N[C@H](Cc2c[nH]c3ccccc23)C1=O)N1CCC(c2nc3ccccc3s2)CC1 5. COc1cccc(-c2nnc3sc(-c4cc(OC)c(OC)c(OC)c4)nn23)c1
MET/HGFR
1. O=S(=O)(c1ccccc1)c1nnn2c1nc(Nc1cccc(F)c1)c1ccccc12 2. COc1ccc(/C=C2/Cc3c(Cl)cccc3C2=O)cc1C(=O)c1c[nH]c(C)cc1=O 3. C[C@H]1CN(C(=O)[C@@H]2CCN(c3ccccc3)C2)c2ccccc2O1 4. Cc1ccc(-c2nnc(S(=O)(=O)CC(=O)NC3CCCC3)n2C)cc1 5. Cc1ccccc1NC(=O)C(=O)NCCCc1nc2ccccc2[nH]1
NR3C1/GR
1. C[C@H](CNC(=O)[C@H]1C[C@@H]1c1ccccc1)NC(=O)[C@@H]1C[C@@H]1C1=CCC=CC1 2. C=CCN1C(=O)/C(=C/c2ccc(Cl)c(Cl)c2)S/C1=N\C1C=CC=CN1 3. Cn1cnc(C[NH2+]Cc2ccc(C(C)(C)C)cc2)n1 4. COC(=O)N1CCc2nc(NC(=O)c3cc(Cl)sc3Cl)sc2C1 5. COc1cc([C@@H](N)C(F)(F)F)c(Br)c(Br)c1O
P2RY12/P2Y12
1. C1=Cc2c(ccc3c2CC(c2cc4ccccc4o2)CC3)C1 2. CCn1c(SCC(=O)[O-])nnc1-c1ccc(C)cc1 3. O=c1[nH]c2ccc(NCc3cccc(OCc4ccc(Cl)cc4)c3)cc2[nH]1 4. FC1=CCN(c2nc3nccc(-c4cccc(C(F)(F)F)c4)n3n2)C1 5. C/[NH+]=C(/NCCc1ccc(F)cc1)N1CCC[C@H](C)C1
PIK3CA
1. CCOc1ccc([C@H]2CN(C(=O)Nc3ccc(C)c(C(=O)NC)c3)CCO2)cc1 2. O=C(Cn1ncc(=O)c2ccccc21)NC[C@@H]1CCCN(c2ncc3c(n2)CCCC3)C1 3. Cc1cc(N2CCSCC2)ccc1Nc1cc(-c2cccnc2)nc2ncnn12 4. COc1cccc(CNC(=O)CCc2nnc3ccc(N4C=CCCC4)nn23)c1 5. CC(=O)Nc1c(C)cc(NC(=O)CCc2ccc(F)cc2)cc1C
PSEN1
1. O=C(N[C@@]1(Cc2ccccc2)NC(c2ccccc2)=NC1=O)c1ccccc1 2. COc1ccccc1N1Cc2cccc(N)c2C1 3. Cc1cc(F)c([N+](=O)[O-])cc1S(=O)(=O)NCc1cscn1 4. Cc1noc([C@@H]2CCCN2C(=O)c2cc(C3CC3)on2)n1 5. O[C@H](CN(Cc1ncccc1C(F)(F)F)C1CC1)c1ccccc1
PTGS1/COX1
1. N#Cc1ccc(C2=CCN(c3ncnc4ccccc34)C2)cc1 2. COc1ccc(F)cc1NC(=O)CCc1ccc2c(c1)OCO2 3. Fc1ccc(N2CC[C@@H](Cc3cccnc3)C2)cc1 4. Cc1cccc(-c2ccc(C#N)c(C#N)c2)c1 5. O=C(NCCC(=O)N1CCOCC1)C1CCN(c2ncnc3ccccc23)CC1
PTGS2/COX2
1. Fc1cccc(CCNc2ccccc2)c1 2. Cc1cc(C)c(COc2ccc(CO)nc2)c(C)c1 3. C#CCNC(=O)CCN1C(=O)COc2ccccc21 4. COc1ccc(/C=C2\SC(=N)NC2=O)cc1OCc1ccccc1 5. Cc1cc(COc2ccc(CO)nc2)c2cc(Br)ccc2n1
SHP2/PTPN11
1. Cc1ccc(C2=C[C@H](C(=O)N3CCN(C(=O)[C@@H]4NSc5ccc(C)cc54)CC3)N=N2)cc1 2. Clc1nc([C@H]2OCCO[C@@H]2C2=C3CCCC3C3CCCC3=N2)nc2c1CCC2 3. C1=C(COc2ccc(-n3cnnn3)cc2)CC(n2cnnn2)=C1 4. O=S(=O)(NC1=C2CCCC2=CCN1)c1ccccc1F 5. CCC1=CCC(C2=C[C@H](C(=O)c3ccccc3F)N=N2)C=C1
SLC6A2
1. COc1cccc(CC(=O)Nc2ccc3c(c2)C(N)=CCN3C)c1 2. N#Cc1cccc(C=Cc2cccc(C#N)c2)c1 3. Cc1cc(N)c(S(=O)(=O)NC2C(C)(C)C2(C)C)c(Cl)c1 4. NC1=C(c2cccc(-c3cccc(N)c3)c2)CC(Cl)=C1 5. Cc1cccc(-c2ncc(NF)cn2)c1
14
Target
Returned molecules
TNF
1. Cc1cc(C(=O)CN2C(=O)N[C@@](C)(c3ccc(Cl)cc3)C2=O)c(C)n1-c1ccccc1 2. COc1cccc(NS(=O)(=O)c2cccc(C(F)(F)F)c2)c1 3. N#Cc1ccc(OC[C@H](O)CN2CCN(c3ccccc3F)CC2)cc1 4. O=C(Cc1cccc2cccnc12)N(C1CC1)[C@H]1CCS(=O)(=O)C1 5. Cc1nc(S(=O)(=O)N2CCN(Cc3ccc([C@H]4C[C@@H]4C)o3)CC2)cn1C
15
does not merely shorten memory; it rewrites available evidence into a more decision-relevant planner state.
D Additional Main-Result Diagnostics D.1 Iteration-cutoff comparison at 2/4/6/8/10 iterations
E.1
To better understand when the performance gain emerges, we report the cutoff results at 2/4/6/8/10 iterations in Table 10. We keep this table in the appendix because its main value lies in the trajectory pattern rather than in any single cell. Consistent with the ablation study in the main text, we retain only the variants used in the final analysis: the LIDDiA baseline, Set-level Repair Signal, CACM w/o corrective selection, CACM w/o dynamic compression, and full CACM. The table supports the same qualitative story as the main-text ablation. The LIDDiA baseline is strongly front-loaded: targets that succeed usually succeed early, while targets that fail early seldom recover later. By contrast, CACM continues to improve after the earliest iterations and exhibits a clear late-stage re-generation pattern. This is consistent with the claim that the corrective control loop is not merely accelerating the same local refinement behavior, but also helping the agent leave unproductive trajectories and reenter exploration when the current pool saturates. The intermediate variants also follow the expected ordering: Set-level Repair Signal already improves over the LIDDiA baseline, while removing corrective selection or dynamic compression weakens either reliability or compactness relative to full CACM.
E
CACM snapshot: KIT at iteration 4 Target: KIT Method: CACM Iteration shown: 4 (raw step 3) Total memory length: 2,389 characters Channel lengths: static 598; dynamic 596; corrective 1,195. Task requirements At least 5 molecules. Vina score must be lower than −7.77. Novelty must be at least 0.80. Diversity must be at least 0.80. QED must be better than 0.43. SAScore must be better than 2.77. Lipinski must be better than or at least 3.19. Pocket summary Atom count: 277; residue count: 36; chain count: 1. Bounding-box size: [20.348, 24.401, 24.296]. Pocket center: [34.162, 14.721, 39.277]. Top residue types: LEU(5), VAL(5), THR(4), ILE(4), LYS(3). Hydrophobic ratio: 0.528; positive ratio: 0.111; negative ratio: 0.083; aromatic ratio: 0.111. Current selected molecule pools MOL003: score 0.6413; size 100; diversity 0.8487; worst Vina −3.676; minimum novelty 0.685; minimum QED 0.306; maximum SAS 2.769. MOL001: score 0.6615; size 100; diversity 0.8781; worst Vina −3.932; minimum novelty 0.695; minimum QED 0.343; maximum SAS 5.229. MOL002: score 0.6570; size 100; diversity 0.8592; worst Vina −7.358; minimum novelty 0.685; minimum QED 0.212; maximum SAS 4.682.
Representative Planner-Facing Memory on KIT
This appendix juxtaposes representative planner-facing memory snapshots for the target KIT under CACM and the LIDDiA baseline. We choose this case because it makes the control difference directly visible. Both methods expose substantial trajectory information to the planner, but they organize that information very differently. The CACM snapshot shows a compact and decision-relevant control state that explicitly summarizes task constraints, pocket context, selected molecule pools, recent actions, and corrective guidance derived from the current failure mode. The LIDDiA baseline snapshot, by contrast, shows the same target through a chronologically accumulated planner-facing memory stream that interleaves task restatement, planner reasoning, chosen actions, action outputs, evaluation summaries, and success judgments. Importantly, the baseline snapshot is shown at iteration 6/10 as an intermediate failure-case state rather than a successful stopping point. The purpose of presenting both snapshots is not simply to compare memory length, but to make visible the difference between information accumulation and control-oriented write-back.
Recent actions Iteration-history entry 0: Generate → MOL001; strict protocol pass = False. Iteration-history entry 1: Optimize → MOL002; strict protocol pass = False. Iteration-history entry 2: Optimize → MOL003; strict protocol pass = False. Selected corrective entry Iteration 2; failure family: binding bottleneck; severity: 4.094; recommended bias: Code. Failed requirements: Vina score < −7.77, novelty ≥ 0.80, QED > 0.43, and Lipinski ≥ 3.19. Repair hint: the current pool already contains 24 molecules that satisfy all per-molecule thresholds, so the preferred next step is a code-based repair over the existing pool: filter molecules by Vina score, novelty, QED, SAScore, and Lipinski constraints, then construct a diverse subset with at least five molecules.
What is visible in the planner-facing memory. Readers can directly verify that both snapshots contain nontrivial planner-visible evidence in plain text. The key difference is organizational. CACM writes back explicit control fields such as Task requirements, Pocket summary, Current selected molecule pools, Recent actions, and Selected corrective entries. The LIDDiA baseline instead exposes a single appended planner-facing memory stream in which task restatement, action traces, local judgments, and success checks remain interleaved. This contrast is important because it shows that CACM
Note. The raw snapshot retains two identical corrective entries at this point in the trajectory. For readability, we show the duplicated entry only once here.
Why this CACM example matters. This reformatted snapshot makes two points concrete. First, CACM does not simply record that previous attempts failed; it exposes which constraints remain 16
Table 10: Cutoff statistics at 2/4/6/8/10 iterations for the retained variants in the final ablation. Generated
CACM (full)
2 4 6 8 10
26.1 8.2 11.3 5.0 5.0
100.0 / 26.1 95.9 / 22.0 98.6 / 24.7 86.3 / 12.9 79.6 / 13.7 93.9 / 20.0 70.6 / 5.0 100.0 / 8.2 99.8 / 7.9 99.8 / 7.9 96.3 / 7.0 92.9 / 5.5 99.1 / 7.3 91.5 / 4.7 100.0 / 11.3 98.2 / 9.5 99.8 / 11.2 98.2 / 9.6 95.6 / 7.0 96.8 / 8.2 93.7 / 5.0 100.0 / 5.0 100.0 / 5.0 100.0 / 5.0 100.0 / 5.0 100.0 / 5.0 100.0 / 5.0 100.0 / 5.0 100.0 / 5.0 100.0 / 5.0 100.0 / 5.0 100.0 / 5.0 100.0 / 5.0 100.0 / 5.0 100.0 / 5.0
30/30 30/30 30/30 30/30 30/30
30/30 30/30 30/30 30/30 30/30
20/30 27/30 29/30 30/30 30/30
29/30 29/30 29/30 30/30 30/30
18/30 27/30 28/30 30/30 30/30
18.4
100.0 / 18.4
94.8 / 13.3
99.0 / 17.5
95.0 / 13.4
88.3 / 10.6
95.2 / 13.7
83.3 / 5.6
30/30
30/30
27/30
29/30
24/30
5.7 12.1 5.7 5.7
100.0 / 5.7 100.0 / 12.1 100.0 / 5.7 100.0 / 5.7
100.0 / 5.7 96.8 / 8.9 100.0 / 5.7 100.0 / 5.7
100.0 / 5.7 99.7 / 11.8 100.0 / 5.7 100.0 / 5.7
94.7 / 5.4 95.8 / 7.9 100.0 / 5.7 100.0 / 5.7
95.3 / 5.4 97.0 / 9.1 100.0 / 5.7 100.0 / 5.7
100.0 / 5.7 94.0 / 5.4 96.1 / 8.2 93.4 / 5.5 100.0 / 5.7 100.0 / 5.7 100.0 / 5.7 100.0 / 5.7
30/30 30/30 30/30 30/30
29/30 30/30 29/30 29/30
27/30 28/30 29/30 29/30
28/30 29/30 30/30 30/30
27/30 28/30 29/30 29/30
2
14.2
100.0 / 14.2
91.9 / 11.5
97.8 / 13.6
83.1 / 8.4
79.5 / 8.8
94.2 / 12.8
65.8 / 4.2
29/30
29/30
17/30
24/30
13/30
4 6 8 10
11.9 6.0 6.4 8.0
100.0 / 11.9 100.0 / 6.0 100.0 / 6.4 100.0 / 8.0
95.7 / 10.4 97.5 / 5.5 96.7 / 5.8 97.3 / 7.0
98.4 / 11.5 100.0 / 6.0 99.5 / 6.3 99.5 / 7.9
88.9 / 7.8 95.0 / 5.0 95.5 / 5.5 94.6 / 5.9
85.3 / 8.8 97.5 / 5.5 97.0 / 5.8 95.1 / 6.2
94.1 / 9.2 97.0 / 5.4 95.0 / 5.4 97.5 / 6.8
75.7 / 4.7 93.3 / 4.6 90.8 / 4.6 90.8 / 4.6
29/30 28/30 29/30 28/30
28/30 26/30 28/30 27/30
22/30 26/30 27/30 27/30
26/30 26/30 27/30 26/30
20/30 24/30 25/30 25/30
2
10.7
96.7 / 10.7
93.2 / 9.9
95.6 / 10.3
87.4 / 8.1
80.9 / 6.4
92.0 / 9.7
73.2 / 4.7
28/30
28/30
19/30
25/30
18/30
4 6 8 10
7.6 6.6 8.9 6.7
100.0 / 7.6 100.0 / 6.6 100.0 / 8.9 100.0 / 6.7
94.0 / 6.4 97.8 / 6.1 97.1 / 7.7 98.0 / 6.3
97.0 / 7.0 98.8 / 6.3 98.8 / 8.6 99.7 / 6.7
92.8 / 6.2 93.5 / 5.7 94.7 / 7.2 97.5 / 6.2
93.8 / 6.5 98.0 / 6.4 91.7 / 7.3 98.5 / 6.4
95.5 / 6.7 97.5 / 6.1 95.7 / 7.6 97.3 / 6.2
87.2 / 5.2 89.8 / 5.1 85.4 / 5.3 94.7 / 5.7
28/30 28/30 29/30 27/30
26/30 26/30 28/30 27/30
23/30 23/30 24/30 28/30
27/30 27/30 27/30 27/30
23/30 23/30 24/30 26/30
2 4 6 8 10
21.3 22.6 19.4 19.7 21.0
96.7 / 21.3 90.2 / 17.5 100.0 / 22.6 93.5 / 18.8 100.0 / 19.4 98.8 / 19.1 100.0 / 19.7 98.7 / 19.5 100.0 / 21.0 96.6 / 20.2
90.2 / 17.5 93.5 / 18.8 99.2 / 19.2 99.8 / 19.7 97.0 / 20.2
90.2 / 17.5 93.5 / 18.8 98.3 / 19.0 97.0 / 19.1 93.5 / 19.7
90.2 / 17.5 93.5 / 18.8 96.7 / 18.7 97.8 / 19.3 97.3 / 20.6
90.2 / 17.5 93.5 / 18.8 98.0 / 19.0 96.3 / 19.0 97.0 / 20.3
90.2 / 17.5 93.5 / 18.8 94.7 / 18.3 93.7 / 18.5 88.8 / 18.7
27/30 28/30 24/30 25/30 26/30
23/30 25/30 22/30 24/30 25/30
22/30 25/30 21/30 22/30 23/30
26/30 26/30 22/30 23/30 24/30
20/30 22/30 20/30 21/30 22/30
CACM w/o corrective selection
Set-level Repair Signal
LIDDiA (DeepSeek)
QED
LRF
SAS
VNA
NVT
HQ
𝑁 ≥5&DVS 𝑁 ≥5&HQ DVS&HQ
Iter
CACM w/o 2 dynamic compression 4 6 8 10
Valid
DVS> 0.8
Method
TSR
Table 11: Success-truncated controller-side token usage on the 30-target benchmark. For each target, tokens are accumulated only up to the first successful stopping point; if no success is reached, the full 10-iteration budget is used. “Extra” denotes the metric-judgment stage for the LIDDiA baseline and the diagnosis stage for CACM.
Method
Planner / target
Extra / target
Extra share
Total / target
Planner / iter
Extra / iter
Total / iter
LIDDiA baseline CACM
24,799.0 9,927.9
8,719.3 13,114.4
26.0% 56.9%
33,518.3 23,042.2
5,510.9 3,423.4
1,937.6 4,522.2
7,448.5 7,945.6
Table 12: Success-truncated wall-clock runtime on the 30target benchmark. For each target, runtime is accumulated only up to the first successful stopping point; if no success is reached, the full 10-iteration budget is used.
Method LIDDiA baseline CACM
Avg. cutoff Minutes iterations / iter 4.40 3.07
10.11 15.14
Iteration shown: 6/10 (failure-case snapshot) Approximate displayed memory length: 2,904 characters Organization: single appended planner-facing memory stream; no static/dynamic/corrective channel split.
Minutes / target
Planner-facing memory (faithfully reformatted for display, original chronological style preserved)
45.49 43.91
Initial task: design a set of molecules for KIT. Requirements: at least 5 molecules; Vina score lower than −7.77; novelty at least 0.80; diversity at least 0.80; QED better than 0.43; SAScore better than 2.77; Lipinski better than or at least 3.19. Available actions: Generate, Optimize, Code.
unsatisfied and turns them into an explicit repair instruction. Second, the write-back remains structured and compact: instead of feeding the planner a long unfiltered trajectory, CACM surfaces the most decision-relevant pools, actions, and corrective signal in a form that can directly guide the next step.
E.2
Iteration 1. Planner response: start with Generate because no candidate pool is available yet. Action: Generate → MOL001. Evaluation after iteration 1: requirements not satisfied. Failed constraints include Vina score, novelty, QED, SAScore, and Lipinski. Current conclusion: generated molecules are diverse enough to explore, but binding and several per-molecule quality indicators remain weak.
LIDDiA baseline snapshot: KIT at iteration 6/10 Target: KIT Method: LIDDiA baseline
17
Why this baseline example matters. This snapshot clarifies the contrast with the CACM memory above. The issue is not that the LIDDiA baseline lacks memory content; on the contrary, even at this intermediate failure-case state, the planner already sees a substantial amount of accumulated text. The issue is that the write-back remains an appended trajectory memory rather than a compact control state. As a result, evidence about the current bottleneck is present, but it is mixed with repeated thresholds, past local failures, and free-form intermediate reasoning. CACM, by contrast, converts such evidence into a bounded and explicitly decision-oriented planner-visible state.
Iteration 2. Planner response: since binding and quality remain poor, try filtering the current pool by the known thresholds and keep the better subset. Action: Code on MOL001 → MOL002. Evaluation after iteration 2: only 3 molecules remain after filtering, so the pool now fails the size requirement even though some molecule-level properties improve. Current conclusion: threshold-based filtering may help quality, but it can also shrink the pool too aggressively. Iteration 3. Planner response: because direct filtering left too few molecules, try improving the pool itself, especially docking, before filtering again. Action: Optimize on MOL001 with Vina-oriented objective → MOL003. Evaluation after iteration 3: requirements still not satisfied. Failed constraints again include Vina score, novelty, QED, SAScore, and Lipinski. Current conclusion: optimization changes the pool, but the dominant bottleneck is still unclear in the appended memory because multiple failed constraints keep appearing together.
F
Success-Truncated Controller-side Token Usage
We additionally analyze controller-side token usage under a successtruncated protocol. For each target, we accumulate all logged controllerside tokens only up to the first successful stopping point recorded in the trajectory; if no success is reached, we count the full 10iteration budget. This yields a fairer measure of practical cost than averaging over forced full-length runs. Table 11 separates the controller-side budget into the planner and an extra controller-side stage. For the LIDDiA baseline, this extra cost comes from the metric-judgment call used to assess whether the current pool satisfies the stopping condition. For CACM, it comes from the additional diagnosis call. The table reports both the average token usage per target until success and the corresponding average per active iteration. Two observations are important. First, the LIDDiA baseline is not a single-call controller in practice: its metric-judgment stage already contributes a nontrivial fraction of total controller-side cost, accounting for 26.0% of the token budget up to success. Second, CACM does introduce a larger auxiliary controller-side share, but at the same time sharply reduces planner consumption. Consequently, although the two methods are close on a per-iteration basis, CACM uses fewer controller-side tokens overall when measured up to success at the target level.
Iteration 4. Planner response: combine information from MOL001, MOL002, and MOL003, then filter using the target constraints again. Action: Code on MOL001, MOL002, and MOL003 → MOL004. Evaluation after iteration 4: deterministic metric check reports that the task requirements are satisfied. Success judgment text appended to memory: Answer: NO. Reason given in the memory: QED is around 0.43, and the planner is not fully confident that the strict inequality “better than 0.43” is satisfied for the returned pool. Iteration 5. Planner response: the main issue may now be the QED boundary rather than binding, so apply another code-based filter to keep only molecules with QED strictly above 0.43, while still trying to preserve the set size and diversity conditions. Action: Code on MOL004 → MOL005. Evaluation after iteration 5: deterministic metric check again reports that the task requirements are satisfied. Success judgment text appended to memory: Answer: NO. Reason again focuses on the strict QED boundary and confidence about whether every returned molecule exceeds the threshold.
G
Iteration 6. The planner-facing memory at this point already contains the full original task specification, repeated mentions of the same thresholds, two code-filtering attempts, one optimization attempt, repeated statements that several constraints fail together, and then repeated local reasoning about whether QED is strictly greater than 0.43. The latest planner response therefore mixes several concerns at once: maybe continue coding because the QED boundary is still uncertain; maybe optimize again because binding was poor earlier; maybe combine multiple pools because filtering alone may reduce the set size. The memory has become longer and more detailed, but the dominant failure mode is still not written back as an explicit corrective summary.
Success-Truncated Runtime Overhead
We next report wall-clock runtime under the same success-truncated protocol. For each target, runtime is measured only up to the first successful stopping point; if the target does not succeed, we count the full 10-iteration runtime. We then average both the target-level runtime and the per-iteration runtime over the 30-target benchmark. Table 12 shows the same trade-off pattern as the token analysis. CACM is slower for each active iteration because it adds an extra controller-side call. However, CACM reaches successful stopping in fewer iterations on average, which lowers the overall time spent per target until success. This supports the claim that the bounded corrective controller is not merely paying extra time at every step without return; rather, it trades a moderate per-iteration overhead for lower end-to-end cost at the trajectory level.
Visible characteristics of the appended memory at this point: old failures and recent local issues coexist in the same stream; requirement text is restated multiple times; the planner sees action logs and evaluation summaries, but no ranked retained pools, no compact recent-action abstraction, and no selected corrective entry.
18
References
[20] Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, Sebastian Riedel, and Douwe Kiela. 2020. Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. In Advances in Neural Information Processing Systems. https://proceedings.neurips.cc/paper/2020/hash/ 6b493230205f780e1bc26945df7481e5-Abstract.html [21] Yibo Li, Jiezhong Pei, and Luhua Lai. 2021. Structure-Based de Novo Drug Design Using 3D Deep Generative Models. Chemical Science 12 (2021), 13664–13675. doi:10.1039/D1SC04444C [22] Haitao Lin, Yufei Huang, Odin Zhang, Yunfan Liu, Lirong Wu, Siyuan Li, Zhiyuan Chen, and Stan Z. Li. 2023. Functional-Group-Based Diffusion for Pocket-Specific Molecule Generation and Elaboration. In Advances in Neural Information Processing Systems. https://openreview.net/forum?id=lRG11M91dx [23] Christopher A. Lipinski, Franco Lombardo, Beryl W. Dominy, and Paul J. Feeney. 2001. Experimental and Computational Approaches to Estimate Solubility and Permeability in Drug Discovery and Development Settings. Advanced Drug Delivery Reviews 46, 1–3 (2001), 3–26. doi:10.1016/S0169-409X(00)00129-0 [24] Aman Madaan, Niket Tandon, Prakhar Gupta, Skyler Hallinan, Luyu Gao, Sarah Wiegreffe, Uri Alon, Nouha Dziri, Shrimai Prabhumoye, Yiming Yang, Shashank Gupta, Bodhisattwa Prasad Majumder, Katherine Hermann, Sean Welleck, Amir Yazdanbakhsh, and Peter Clark. 2023. SELF-REFINE: Iterative Refinement with Self-Feedback. arXiv preprint arXiv:2303.17651 (2023). https://arxiv.org/abs/2303. 17651 [25] Andrew D. McNaughton, Gautham Krishna Sankar Ramalaxmi, Agustin Kruel, Carter R. Knutson, Rohith A. Varikoti, and Neeraj Kumar. 2024. CACTUS: Chemistry Agent Connecting Tool Usage to Science. ACS Omega 9, 46 (2024), 46563–46573. doi:10.1021/acsomega.4c08408 [26] Janghoon Ock, Radheesh Sharma Meda, Srivathsan Badrinarayanan, Neha S. Aluru, Achuth Chandrasekhar, and Amir Barati Farimani. 2026. Large Language Model Agent for Modular Task Execution in Drug Discovery. Journal of Chemical Information and Modeling 66, 4 (2026), 2055–2068. doi:10.1021/acs.jcim.5c02454 [27] Xingang Peng, Shitong Luo, Jiaqi Guan, Qi Xie, Jian Peng, and Jianzhu Ma. 2022. Pocket2Mol: Efficient Molecular Sampling Based on 3D Protein Pockets. In Proceedings of the 39th International Conference on Machine Learning (Proceedings of Machine Learning Research, Vol. 162). PMLR, 17644–17655. https://proceedings. mlr.press/v162/peng22b.html [28] Matthew Ragoza, Tomohide Masuda, and David R. Koes. 2022. Generating 3D Molecules Conditional on Receptor Binding Sites with Deep Generative Models. Chemical Science 13, 9 (2022), 2701–2713. doi:10.1039/D1SC05976A [29] Mayk Caldas Ramos, Christopher J. Collison, and Andrew D. White. 2025. A Review of Large Language Models and Autonomous Agents in Chemistry. Chemical Science 16, 6 (2025), 2514–2572. doi:10.1039/D4SC03921A [30] Timo Schick, Jane Dwivedi-Yu, Roberto Dessi, Roberta Raileanu, Maria Lomeli, Eric Hambro, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. 2023. Toolformer: Language Models Can Teach Themselves to Use Tools. In Advances in Neural Information Processing Systems. https://openreview.net/forum?id= Yacmpz84TH [31] Arne Schneuing, Charles Harris, Yuanqi Du, Kieran Didi, Arian Jamasb, Ilia Igashov, Weitao Du, Carla Gomes, Tom Blundell, Pietro Liò, Max Welling, Michael Bronstein, and Bruno Correia. 2024. Structure-Based Drug Design with Equivariant Diffusion Models. Nature Computational Science 4, 12 (2024), 899–909. doi:10.1038/s43588-024-00737-x [32] Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik R. Narasimhan, and Shunyu Yao. 2023. Reflexion: Language Agents with Verbal Reinforcement Learning. In Advances in Neural Information Processing Systems. https: //openreview.net/forum?id=vAElhFcKW6 [33] Yidan Tang, Rocco Moretti, and Jens Meiler. 2024. Recent Advances in Automated Structure-Based De Novo Drug Design. Journal of Chemical Information and Modeling 64, 6 (2024), 1794–1805. doi:10.1021/acs.jcim.4c00247 [34] Oleg Trott and Arthur J. Olson. 2010. AutoDock Vina: Improving the Speed and Accuracy of Docking with a New Scoring Function, Efficient Optimization, and Multithreading. Journal of Computational Chemistry 31, 2 (2010), 455–461. doi:10.1002/jcc.21334 [35] Lei Wang, Chen Ma, Xueyang Feng, Zeyu Zhang, Hao Yang, Jingsen Zhang, Zhiyuan Chen, Jiakai Tang, Xu Chen, Yankai Lin, Wayne Xin Zhao, Zhewei Wei, and Ji-Rong Wen. 2024. A Survey on Large Language Model Based Autonomous Agents. Frontiers of Computer Science 18 (2024), 186345. doi:10.1007/s11704-02440231-1 [36] Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Beibin Li, Erkang Zhu, Li Jiang, Xiaoyun Zhang, Shaokun Zhang, Jiale Liu, Ahmed Hassan Awadallah, Ryen W. White, Doug Burger, and Chi Wang. 2024. AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation. In First Conference on Language Modeling. https://openreview.net/forum?id=BAakY1hNKS [37] Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R. Narasimhan, and Yuan Cao. 2023. ReAct: Synergizing Reasoning and Acting in Language Models. In The Eleventh International Conference on Learning Representations. https://openreview.net/forum?id=WE_vluYUL-X
[1] Amira Alakhdar, Barnabás Póczos, and Newell Washburn. 2024. Diffusion Models in De Novo Drug Design. Journal of Chemical Information and Modeling 64, 19 (2024), 7238–7256. doi:10.1021/acs.jcim.4c01107 [2] Reza Averly, Frazier N. Baker, Ian A. Watson, and Xia Ning. 2025. LIDDIA: Language-based Intelligent Drug Discovery Agent. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, Christos Christodoulopoulos, Tanmoy Chakraborty, Carolyn Rose, and Violet Peng (Eds.). Association for Computational Linguistics, Suzhou, China, 12004–12028. doi:10.18653/v1/2025.emnlp-main.603 [3] Andrius Bernatavicius, Martin Šícho, Antonius P. A. Janssen, Alan Kai Hassen, Mike Preuss, and Gerard J. P. van Westen. 2024. AlphaFold Meets de Novo Drug Design: Leveraging Structural Protein Information in Multitarget Molecular Generative Models. Journal of Chemical Information and Modeling 64, 21 (2024), 8113–8122. doi:10.1021/acs.jcim.4c00309 [4] George R. Bickerton, Gaia V. Paolini, Jérôme Besnard, Sorel Muresan, and Andrew L. Hopkins. 2012. Quantifying the Chemical Beauty of Drugs. Nature Chemistry 4, 2 (2012), 90–98. doi:10.1038/nchem.1243 [5] Benjamin E. Blass. 2021. Drug Discovery and Development: An Overview of Modern Methods and Principles. In Basic Principles of Drug Discovery and Development (2 ed.), Benjamin E. Blass (Ed.). Academic Press, 1–41. doi:10.1016/ B978-0-12-817214-8.00001-4 [6] Daniil A. Boiko, Robert MacKnight, Ben Kline, and Gabe Gomes. 2023. Autonomous Chemical Research with Large Language Models. Nature 624, 7992 (2023), 570–578. doi:10.1038/s41586-023-06792-0 [7] Andres M. Bran, Sam Cox, Oliver Schilter, Carlo Baldassari, Andrew D. White, and Philippe Schwaller. 2024. Augmenting Large Language Models with Chemistry Tools. Nature Machine Intelligence 6, 5 (2024), 525–535. doi:10.1038/s42256-02400832-8 [8] Ziqi Chen, Bo Peng, Tianhua Zhai, Daniel Adu-Ampratwum, and Xia Ning. 2025. Generating 3D Small Binding Molecules Using Shape-Conditioned Diffusion Models with Guidance. Nature Machine Intelligence (2025). doi:10.1038/s42256025-01030-w [9] Peter Ertl and Ansgar Schuffenhauer. 2009. Estimation of Synthetic Accessibility Score of Drug-Like Molecules Based on Molecular Complexity and Fragment Contributions. Journal of Cheminformatics 1 (2009), 8. doi:10.1186/1758-2946-1-8 [10] Shanghua Gao, Ada Fang, Yepeng Huang, Valentina Giunchiglia, Ayush Noori, Jonathan Richard Schwarz, Yasha Ektefaie, Jovana Kondic, and Marinka Zitnik. 2024. Empowering Biomedical Discovery with AI Agents. Cell 187, 22 (2024), 6125–6151. doi:10.1016/j.cell.2024.09.022 [11] Alireza Ghafarollahi and Markus J. Buehler. 2024. ProtAgents: Protein Discovery via Large Language Model Multi-Agent Collaborations Combining Physics and Machine Learning. Digital Discovery 3, 7 (2024), 1389–1409. doi:10.1039/D4DD00013G [12] Zhibin Gou, Zhihong Shao, Yeyun Gong, Yelong Shen, Yujiu Yang, Nan Duan, and Weizhu Chen. 2023. CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing. arXiv preprint arXiv:2305.11738 (2023). https: //arxiv.org/abs/2305.11738 [13] Jiaqi Guan, Wesley Wei Qian, Xingang Peng, Yufeng Su, Jian Peng, and Jianzhu Ma. 2023. 3D Equivariant Diffusion for Target-Aware Molecule Generation and Affinity Prediction. In The Eleventh International Conference on Learning Representations. https://openreview.net/forum?id=kJqXEPXMsE0 [14] Jiaqi Guan, Xiangxin Zhou, Yuwei Yang, Yu Bao, Jian Peng, Jianzhu Ma, Qiang Liu, Liang Wang, and Quanquan Gu. 2023. DecompDiff: Diffusion Models with Decomposed Priors for Structure-Based Drug Design. In Proceedings of the 40th International Conference on Machine Learning (Proceedings of Machine Learning Research, Vol. 202). PMLR, 11827–11846. https://proceedings.mlr.press/v202/ guan23a.html [15] Lei Huang, Tingyang Xu, Yang Yu, Peilin Zhao, Xingjian Chen, Jing Han, Zhi Xie, Hailong Li, Wenge Zhong, Ka-Chun Wong, and Hengtong Zhang. 2024. A Dual Diffusion Model Enables 3D Molecule Generation and Lead Optimization Based on Target Pockets. Nature Communications 15, 1 (2024), 2657. doi:10.1038/s41467024-46569-1 [16] Yoshitaka Inoue, Tianci Song, Xinling Wang, Augustin Luna, and Tianfan Fu. 2024. DrugAgent: Multi-Agent Large Language Model-Based Reasoning for Drug-Target Interaction Prediction. arXiv preprint arXiv:2408.13378 (2024). https: //arxiv.org/abs/2408.13378 [17] Shoichi Ishida, Tomohiro Sato, Teruki Honma, and Kei Terayama. 2025. Large Language Models Open New Way of AI-Assisted Molecule Design for Chemists. Journal of Cheminformatics 17, 1 (2025), 36. doi:10.1186/s13321-025-00984-8 [18] Jan H. Jensen. 2019. A Graph-Based Genetic Algorithm and Generative Model/Monte Carlo Tree Search for the Exploration of Chemical Space. Chemical Science 10, 12 (2019), 3567–3572. doi:10.1039/C8SC05372C [19] Tuan Le, Julian Cremer, Djork-Arné Clevert, and Kristof T. Schütt. 2025. Equivariant Diffusion for Structure-Based de Novo Ligand Generation with LatentConditioning. Journal of Cheminformatics 17, 1 (2025), 90. doi:10.1186/s13321025-01028-x
19
[38] Zeyu Zhang, Quanyu Dai, Xiaohe Bo, Chen Ma, Rui Li, Xu Chen, Jieming Zhu, Zhenhua Dong, and Ji-Rong Wen. 2025. A Survey on the Memory Mechanism of Large Language Model-Based Agents. ACM Transactions on Information Systems 43 (2025), 1–47. doi:10.1145/3748302 [39] Yizhen Zheng, Huan Yee Koh, Jiaxin Ju, Madeleine Yang, Lauren T. May, Geoffrey I. Webb, Li Li, Shirui Pan, and George Church. 2025. Large Language Models for Drug Discovery and Development. Patterns 6, 10 (2025), 101346. doi:10.1016/j.patter.2025.101346 [40] Andy Zhou, Kai Yan, Michal Shlapentokh-Rothman, Haohan Wang, and YuXiong Wang. 2023. Language Agent Tree Search Unifies Reasoning, Acting, and Planning in Language Models. arXiv preprint arXiv:2310.04406 (2023). https: //arxiv.org/abs/2310.04406 [41] Juexiao Zhou, Bin Zhang, Guowei Li, Xiuying Chen, Haoyang Li, Xiaopeng Xu, Siyuan Chen, Wenjia He, Chencheng Xu, Liwei Liu, and Xin Gao. 2024. An AI Agent for Fully Automated Multi-Omic Analyses. Advanced Science 11, 44 (2024), e2407094. doi:10.1002/advs.202407094
20