Protocol Over Hype: Why AI Drug Discovery Agents Need Memory, Not Just Models

Drug discovery is a wonderful place for AI demos. The model proposes a molecule, the molecule looks plausible, a docking score improves, and the slide deck starts to glow with that familiar color: almost-commercial blue.

Then the evaluation protocol arrives and ruins the party.

The problem is simple, and therefore easy to underestimate. A drug discovery agent is rarely asked to return one impressive molecule. It is asked to return a set of molecules that jointly satisfies several requirements: enough candidates, enough diversity, acceptable binding proxies, drug-likeness, synthetic accessibility, novelty, and other threshold-style constraints. One molecule can look good. A few molecules can look good. The final returned pool can still fail.

That is the useful starting point for the arXiv paper Constraint-Aware Corrective Memory for Language-Based Drug Discovery Agents, which introduces CACM, or Constraint-Aware Corrective Memory.¹ The paper is not mainly about a stronger molecular generator. It is not even mainly about a more charming LLM planner. Its real contribution is more prosaic and more important: it treats language-based drug discovery as a protocol-control problem.

This sounds less glamorous than “AI designs drugs.” Good. Glamour is usually where the audit logs go to die.

The failure is not a bad molecule; it is a bad returned set

The paper follows the returned-set task setting used by LIDDiA, a language-based intelligent drug discovery agent benchmark. For each target protein, the agent receives a receptor pocket and natural-language requirements describing what the final molecule pool should satisfy. The agent can choose among actions such as Generate, Optimize, and Code/Screen, using a molecular toolchain that includes Pocket2Mol for structure-based generation, GraphGA for optimization, and AutoDock Vina for docking-based evaluation.

The uncomfortable detail is that success is evaluated at the final pool level. A run succeeds only when the returned set jointly satisfies the protocol. That protocol includes pool size, diversity, docking-related binding proxies, novelty, QED, Lipinski-style compliance, and synthetic accessibility.

This creates a mismatch between how agents act and how they are judged.

At each step, the planner sees local decisions: generate more candidates, optimize an existing pool, screen by thresholds, merge or filter. But the final judgment is global. The returned pool must satisfy all constraints together. A locally sensible action can make the global state worse. Filtering can improve average quality but leave too few molecules. Optimizing for docking can reduce diversity. Keeping many candidates can preserve diversity but weaken worst-case property constraints.

The paper’s core diagnosis is that many agent failures are not failures of imagination. They are failures of state representation. The agent has information, but not in a form that tells it what to repair next.

CACM adds a control layer, not a magic molecule machine

CACM changes the loop around the planner. It does not replace the molecular tools. Instead, it inserts a protocol-aware control mechanism between the current molecule pool and the next planning step.

The loop has three major ideas:

The first move is especially important. CACM audits the current candidate pool using deterministic code. For each requirement, it computes whether the current set satisfies the threshold. When a constraint fails, the system computes a residual: not just “failed,” but how far the current pool is from passing. Negative residuals indicate violated constraints, and their magnitude helps localize the failure.

That audit becomes the source of truth. The language model is not asked to “feel” whether the molecule pool is good enough. It receives an explicit failure description.

The second move is the grounded diagnoser. Given the requirement set, pocket context, current candidate set, and residual vector, it identifies which constraints remain unsatisfied, what failure type dominates, what repair hint should be applied, and which next action should be biased. This is not generic self-reflection. It is not the agent writing itself a motivational note saying “try harder on binding.” It is a protocol-grounded control signal.

The third move is memory organization. CACM splits planner-facing memory into three channels:

This matters because memory is not valuable just because it is long. Long memory can become a landfill with timestamps.

CACM applies channel-wise selection and deterministic formatting before write-back. Static memory keeps stable target and pocket information. Dynamic memory keeps informative pool summaries and recent actions. Corrective memory keeps high-value diagnoses rather than all previous complaints. The result is a planner-facing state that remains compact and predictable across iterations.

The paper’s understated message is that “more context” is not always intelligence. Sometimes it is just a more expensive way to confuse yourself.

The main result is 100%, but that is not the whole point

The headline result is easy to report and easy to misread.

On the 30-target LIDDiA benchmark, the reproduced DeepSeek-based LIDDiA baseline achieves a target success rate of 73.3%, or 22 out of 30 targets. CACM reaches 100.0%, or 30 out of 30 targets. That is a 26.7 percentage-point gain, or a 36.4% relative improvement over the baseline.

Tempting conclusion: CACM is simply “better.” Accurate, but too shallow.

The more interesting result is that CACM does not win by returning huge pools and hoping that something passes. The baseline returns an average final pool size of 21.0 molecules. CACM returns exactly 5.0 molecules on average, matching the minimum returned-set size requirement. The average termination iteration also drops from 4.40 to 3.07.

So the paper is not showing a brute-force search expansion. It is showing a sharper stopping process. CACM learns when the pool is valid, and it returns a compact set rather than carrying extra molecules as insurance.

This distinction is important for business interpretation. In R&D workflows, a system that returns fewer but valid candidates can be more valuable than one that returns a large pile of maybe-useful outputs. Downstream review, docking reruns, medicinal chemistry triage, and experimental prioritization all have real costs. A compact valid set is not just cleaner. It is operationally cheaper.

Individual molecule quality is not the same as set reliability

One subtle part of the paper is that CACM’s advantage is not simply superior molecule-level quality across every metric.

The returned-pool medians show that several baselines remain competitive on individual properties. DiffSMOL has strong novelty median values. Claude and other LLM baselines can look good on QED or other molecule-level summaries. The reproduced LIDDiA baseline is also not weak on every molecule-level statistic.

That is exactly why this paper is useful.

A baseline can produce attractive molecules and still fail the returned-set protocol. It can have a few strong candidates but insufficient diversity. It can pass diversity while failing high-quality constraints. It can improve docking while losing pool size. In a multi-constraint returned-set task, individual molecule metrics are necessary but not sufficient.

The paper’s interpretation is therefore more precise than “CACM makes better molecules.” CACM converts comparable molecule-level quality into stronger set-level validity.

For business readers, this is the difference between optimizing a component and delivering a usable bundle. A procurement system does not succeed because one supplier quote is excellent if the final contract package fails compliance. A financial report automation does not succeed because one table is accurate if the final filing package is incomplete. A drug discovery agent does not succeed because one molecule is pretty if the returned set fails the protocol.

Different industry, same annoying lesson: local quality is not system quality.

The ablation study shows that diagnosis is useful, but selected memory is the system

The ablation results are the most important evidence for the mechanism. They ask a better question than “does CACM work?” They ask what part of CACM carries the improvement.

The paper tests several variants:

This table has three practical lessons.

First, making failure explicit already helps. The repair-signal-only variant improves target success from 73.3% to 86.7%. That suggests a large part of the baseline’s weakness comes from poor failure legibility. The planner is not completely helpless; it just needs the failure stated in a useful form.

Second, memory without selection can backfire. The variant without corrective selection reaches only 83.3%, below the repair-signal-only variant. That result is wonderfully unfashionable. It says that writing back more diagnostic information is not automatically better. If the planner sees too much corrective history, the extra information can become noise.

Third, dynamic compression is not just a token-saving trick. Removing it still gives strong TSR at 96.7%, but the final pool is larger and termination takes longer than full CACM. Compression helps the planner stay focused, not merely stay within a context budget.

So the mechanism is not “add reflection.” It is more disciplined:

1. Audit the returned set.
2. Diagnose the current failure.
3. Select the corrective signal that matters now.
4. Compress the planner-facing state.
5. Let the planner act again.

The order matters. Reflection without audit is vibes. Memory without selection is clutter. Compression without diagnosis is formatting. CACM works because the pieces form a control loop.

The memory analysis explains why compact does not mean thin

The paper’s memory-compression analysis is easy to misread as a cost optimization sidebar. It is more than that.

CACM is not always shorter than the baseline at the beginning. In early iterations, CACM can be longer because it allocates explicit space to protocol-relevant state, diagnosis, and repair guidance. The important difference appears over time. The LIDDiA-style raw-history memory grows almost monotonically as trajectory text accumulates. CACM enters a compact band after the early stage and remains nearly flat.

This is exactly the behavior one would want from a long-horizon agent. The state should become more informative, not merely longer.

The appendix cost diagnostics support the same interpretation. Under success-truncated accounting, CACM reduces controller-side tokens per target from 33,518.3 to 23,042.2, a 31.3% decrease. It also reduces wall-clock time per target from 45.49 to 43.91 minutes, about 3.5% lower.

But there is a trade-off. CACM uses an additional diagnosis call, so each active iteration is slower: 15.14 minutes per iteration versus 10.11 for the baseline. The per-iteration token cost is also slightly higher: 7,945.6 versus 7,448.5. CACM saves overall cost because it reaches success in fewer iterations, not because each step is cheaper.

That distinction matters for deployment. A protocol-control layer may increase per-step cost while reducing trajectory-level cost. Businesses should evaluate these systems by completed valid tasks, not by the cheapest individual call. Counting per-call cost alone is how organizations optimize themselves into very efficient failure.

The strongest reading is not “CACM is cheap.” It is “CACM spends control effort where it can reduce wasted search.”

The KIT case shows the difference between memory and usable memory

The KIT appendix example is valuable because it makes the control mechanism visible.

For the KIT target, CACM’s planner-facing memory at iteration 4 is organized into explicit sections: task requirements, pocket summary, selected molecule pools, recent actions, and selected corrective entries. The corrective memory identifies that diversity is already above the threshold, but QED remains the dominant bottleneck; the repair hint recommends code-based repair over the existing pool, filtering by constraints and constructing a diverse subset of at least five molecules.

The baseline memory is not empty. In fact, that is the point. By iteration 6, the LIDDiA-style memory contains the initial task, repeated threshold descriptions, previous actions, evaluation summaries, local reasoning, and multiple mentions of failed constraints. The problem is not absence of information. The problem is that useful evidence is mixed with repeated requirements, old failures, local judgments, and unresolved reasoning.

CACM turns this kind of history into a control state.

A crude analogy: the baseline gives the planner a meeting transcript. CACM gives it an issue tracker with the current blocker, relevant context, and recommended next action. The transcript is richer. The issue tracker is more useful.

This is why the paper’s contribution should not be filed under “memory length.” It is about memory shape. The planner-facing state is reorganized so that the next decision has fewer excuses to be wrong.

The business lesson is protocol control, not drug-discovery triumphalism

For AI-enabled R&D companies, CACM suggests a practical architecture pattern:

This pattern applies beyond drug discovery. It fits any agentic workflow where the output must satisfy a multi-condition protocol: compliance review, financial reporting, engineering design, due diligence, procurement screening, model evaluation, and regulated document generation.

The inference Cognaptus would draw is not that every enterprise agent needs CACM exactly. The inference is that many useful enterprise agents need a control layer between tool execution and planner memory.

The direct paper result is about in-silico drug discovery on 30 benchmark targets. The business interpretation is broader but should remain bounded: if a workflow has explicit constraints, iterative tool use, and long intermediate history, then CACM’s design pattern is relevant. If the task is one-shot, subjective, or unconstrained, the value of this architecture is less obvious.

There is also a product-design implication. Many AI products still present agent memory as a feature: “the agent remembers everything.” That sounds comforting until everything includes stale failures, repeated threshold text, half-useful tool outputs, and the planner’s earlier confusion. A better product claim would be less romantic: “the agent remembers what changes the next decision.”

Not as catchy. Much closer to useful.

The boundaries are narrow, and that is fine

This paper should not be read as proof that language agents can discover clinically useful drugs. It does not show wet-lab validation. It does not show pharmacokinetics, toxicity, manufacturability, IP freedom-to-operate, or clinical translation. Its evaluation is an in-silico benchmark using docking and medicinal-chemistry proxy metrics.

That limitation is not a defect; it defines the evidence.

What the paper directly shows is that, under the LIDDiA returned-set protocol, CACM improves benchmark reliability by auditing constraints, diagnosing failures, and writing back compact corrective memory. The evidence is strongest for the control-loop claim: explicit protocol diagnosis and selected memory can improve returned-set success.

What remains uncertain is whether the same structure will hold across larger target sets, different molecular generators, different controller models, more realistic medicinal chemistry constraints, and experimental validation pipelines. It would also be useful to see how CACM behaves when constraints conflict, when assays are noisy, or when the best action is to stop because the requirement set itself is unrealistic.

Those are not minor details. In real R&D, “the protocol is wrong” is sometimes the most important diagnosis. CACM, as presented, focuses on satisfying a given protocol, not renegotiating it.

Still, the boundary should not obscure the contribution. Most agent papers are very excited about what the agent can do. This paper is more interested in how the agent knows what it has failed to do. That is a healthier instinct.

Protocol beats spectacle

The useful lesson from CACM is not that AI drug discovery agents now magically work. The lesson is that agent reliability depends on the boring machinery around the model: deterministic checks, grounded failure diagnosis, selected memory, and compact state write-back.

The industry often asks whether the next model will be smart enough to solve complex workflows. Sometimes the better question is whether the workflow has been represented clearly enough for any model to solve it.

CACM’s answer is blunt: do not ask a planner to infer protocol failure from a growing pile of history. Audit the constraints. Diagnose the bottleneck. Keep the memory small enough to be useful and structured enough to be acted on.

That is not anti-model. It is pro-system.

And in drug discovery, as in most serious business workflows, the system is where the demo becomes either a product or a liability.

Cognaptus: Automate the Present, Incubate the Future.