🧬 biology

AgentPLM: Agentic Protein Language Models with Reasoning-Augmented Decoding for Protein Sequence Design

AgentPLM introduces an agentic protein language model that combines Reasoning-Augmented Decoding with external biophysical tools and Contrastive Agent Policy Optimisation to enable online error correction and achieve state-of-the-art performance in diverse protein sequence design tasks.

Original authors: Sahil Rahman, Maxx Richard Rahman

Published 2026-06-02

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Sahil Rahman, Maxx Richard Rahman

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ⚕️ This is an AI-generated explanation of a preprint that has not been peer-reviewed. It is not medical advice. Do not make health decisions based on this content. Read full disclaimer

Imagine you are trying to write a perfect recipe for a new dish.

The Old Way (Passive Protein Models):
Currently, most AI tools for designing proteins work like a chef who has read millions of cookbooks but has never actually tasted the food they are writing about. They generate a recipe (a protein sequence) in one single, fast pass. They rely entirely on their memory of what "usually" works.

The Problem: If the chef writes a recipe that requires baking a cake at 500°F (which would burn it) or mixing ingredients that explode, the AI doesn't know until the very end. It has no way to stop, taste the batter, check the oven, or ask a nutritionist if the ingredients are safe. It just keeps writing until the recipe is done, often resulting in a dish that looks good on paper but fails in the real world.

The New Way (AgentPLM):
The paper introduces AgentPLM, which is like giving that chef a team of expert consultants and a set of tools they can use while they are writing the recipe.

Here is how it works, broken down into simple parts:

1. The "Thinking" Pause (Reasoning-Augmented Decoding)

Instead of just writing the recipe from start to finish, AgentPLM pauses at key moments to ask its experts:

"Will this structure hold together?" (It calls a tool called ESMFold to check the shape).
"Is this too unstable?" (It calls FoldX to check the energy).
"Will this stick to the target?" (It calls AutoDock Vina to check how well it binds).

If the expert says, "Hey, this part is going to fall apart," the AI doesn't just ignore it. It goes back, changes the ingredients (the amino acids), and tries again. It's like a chef tasting the sauce and adjusting the salt before serving the meal, rather than waiting until the customer complains.

2. The "Smart Memory" (Trajectory Memory Buffer)

Since the AI might ask these questions many times while writing one protein, it needs to remember what the experts said earlier. AgentPLM has a special memory bank that keeps track of all the advice it received. This ensures that when it decides on the last ingredient, it remembers that the first ingredient needed to be strong to support the whole structure.

3. Learning from Mistakes (Contrastive Agent Policy Optimisation)

This is the most important part. The AI doesn't just copy "good" recipes it has seen before. It learns when to ask for help.

Imagine training a student. You could just show them a list of "A+ papers" and tell them to copy the style.
Or, you could show them two paths: one where the student asked a teacher for help at the right time and got an A, and another where the student tried to guess everything alone and failed.
AgentPLM learns by comparing these two paths. It learns that asking the "oracle" (the expert tool) isn't just a waste of time; it's the specific moment that turns a bad idea into a good one. It learns the strategy of design, not just the final result.

What Did They Find?

The researchers tested this new "Agentic" chef against the old "Passive" chefs on five different difficult tasks, like designing antibodies (which fight diseases), making enzymes (which speed up chemical reactions), and creating heat-resistant proteins.

The Result: AgentPLM was significantly better. For example, in designing antibodies, it found successful candidates 4 times more often than the best previous AI.
Why? The paper shows that the AI wasn't just guessing faster; it was actually "correcting" its mistakes in real-time. When the AI paused to check its work, it successfully fixed errors that the old models would have missed entirely.

The Bottom Line

AgentPLM changes protein design from a "one-shot guess" into a "conversation." It turns a passive AI that just predicts the next word into an active agent that thinks, checks its work, asks for help, and corrects its course to build better, more stable, and more functional proteins.

Technical Summary: AgentPLM

1. Problem Formulation

Current Protein Language Models (PLMs), such as ESM-2 and ProtTrans, function as "passive oracles." They generate protein sequences in a single forward pass based on next-token prediction trained on evolutionary data. While effective for zero-shot fitness prediction, they suffer from a fundamental limitation: they lack mechanisms to consult external biophysical feedback during generation. Consequently, they cannot dynamically redirect the sequence if a candidate violates thermodynamic stability, structural constraints, or binding specificity. This "structural blindness" and "epistatic blindness" (underestimation of long-range residue dependencies) makes PLMs brittle for out-of-distribution design targets where evolutionary records offer insufficient guidance.

The paper frames protein design not as a static sequence generation task, but as a constrained optimization problem where the objective is to maximize a fitness function $f(S)$ subject to biophysical constraints $C$ , estimated via computational oracles (e.g., ESMFold, FoldX, AutoDock Vina).

2. Methodology: AgentPLM

AgentPLM transforms a pre-trained PLM into an agentic system capable of interleaving autoregressive sequence generation with structured tool calls. The framework is modeled as a Partially Observable Markov Decision Process (POMDP) and consists of four key architectural and algorithmic components:

A. Architecture

Expanded Vocabulary & Tool-Call Initialization: The standard amino acid vocabulary is extended with tokens for tool calls (one per oracle) and an end-of-sequence token. Crucially, tool tokens are initialized semantically using natural language descriptions of the oracles (e.g., "predict change in thermodynamic stability") mapped through the ESM-2 embedding space. This ensures tool tokens reside in the same representational manifold as amino acids from the start, reducing the gradient steps needed for learning.
Tool Context Encoder (TCE): A unified encoder projects heterogeneous oracle outputs (e.g., per-residue pLDDT scores, scalar $\Delta\Delta G$ , binding vectors) into the model's latent space. It uses cross-attention to integrate the oracle output with the model's current hidden state.
Trajectory Memory Buffer (TMB): To manage the context window efficiently, the TMB maintains a constant-size compressed episodic memory of all past tool calls. It injects this memory into the Transformer's residual stream via a learned gating mechanism, allowing the model to condition future generations on the full history of oracle interactions without quadratic attention costs.
Reasoning-Augmented Decoding (RAD): This is the inference-time policy. At each step, the model selects either an amino acid or a tool call.
- Dynamic Backtracking: If a tool call is selected, the oracle is invoked, the TCE/TMB update the context, and the model re-evaluates the current position without advancing the sequence index.
- Structural Self-Consistency (SSC): A novel safety mechanism forces a tool call if the model's internal belief about the partial sequence is inconsistent with the oracle's potential feedback (low SSC score), acting as an active uncertainty resolution step.
- Budget Constraints: To prevent degenerate loops, RAD enforces a minimum gap between calls and a maximum budget of tool calls per sequence.

B. Training Objective: Contrastive Agent Policy Optimisation (CAPO)

The paper introduces CAPO, a trajectory-level extension of Direct Preference Optimisation (DPO).

Data Construction: Trajectories are generated using a reference policy. "Winner" trajectories (high-fitness sequences with coherent tool use) are paired with "Loser" trajectories (low-fitness or contradictory tool use).
Loss Function: The objective contrasts the log-probability of winner trajectories against losers, normalized by a reference policy. This teaches the model when to invoke oracles and how to use their feedback, rather than merely imitating high-fitness sequences.
Auxiliary Loss: A tool-consistency loss penalizes amino acid choices that contradict observed oracle signals, regularizing the policy to align with biophysical reality.

3. Key Contributions

Reasoning-Augmented Decoding (RAD): A decoding strategy that interleaves generation with tool calls, utilizing a learned Tool Context Encoder and Trajectory Memory Buffer trained end-to-end on protein engineering objectives.
Contrastive Agent Policy Optimisation (CAPO): A novel training objective that learns the timing and utility of oracle feedback by contrasting high-fitness trajectories with coherent tool use against low-fitness ones.
State-of-the-Art Performance: The framework demonstrates that agentic reasoning, rather than just increased compute or larger models, drives performance gains in complex protein design tasks.

4. Experimental Results

AgentPLM was evaluated on five benchmark tasks: Thermostability (ThermoStab-75), Antibody Optimization (AntibodyOpt-VH), Enzyme Design (EnzymeDesign-EC3), Protein-Protein Interaction (PPI-Interface), and Zero-Shot Fitness Prediction.

Performance Gains: AgentPLM achieved state-of-the-art results across all tasks. Notably, it improved the antibody top-10% hit rate by 2.79× over the strongest passive baseline (ESM-2) and achieved a 41% improvement in normalized $k_{cat}/K_m$ for enzyme design over the next best baseline (ProtAgent).
Mechanistic Evidence:
- Trajectory Analysis: Analysis of tool-call density revealed a learned "temporal division of labor": ESMFold calls peaked early (fold compatibility), FoldX calls peaked mid-sequence (stability at junctions), and AutoDock Vina calls peaked late (binding interface formation). This mirrors expert human reasoning strategies.
- Online Error Correction: Integrated gradient attribution showed that after a destabilizing FoldX call, attention mass concentrated specifically on the affected residues (1.8× increase), confirming the model actively redirects generation based on oracle feedback without explicit backtracking.
Ablation Studies: Removing RAD reduced performance by ~30-46%, confirming that online feedback is the primary driver. Replacing CAPO with standard Supervised Fine-Tuning (SFT) reduced performance, proving that the contrastive objective is essential for learning when to use tools.

5. Significance and Claims

The paper claims that AgentPLM addresses the fundamental mismatch between the static nature of current PLMs and the iterative, feedback-driven nature of expert protein engineering. By treating protein design as a sequential decision problem with online biophysical feedback, AgentPLM achieves performance gains that passive models cannot replicate.

The authors emphasize that these gains arise from qualitatively different reasoning trajectories rather than additional compute. The work supports the view that agentic and generative paradigms are complementary: the evolutionary prior of models like ESM-2 is necessary but insufficient for complex design, and RAD supplies the iterative refinement required to satisfy simultaneous, non-additive constraints (thermostability, solubility, binding). The paper concludes that this framework provides a pathway to robust, out-of-distribution protein design where evolutionary signals alone are inadequate.