Suppress, Don't Delete: Inhibitory Gating for Self-Evolving Prompt Libraries

Systems that improve an LLM agent by having another LLM critique its failures and rewrite its instructions, usually called "textual gradient" optimizers, share one failure mode. Every fix adds text. After many rounds the instruction set swells with patches that contradict each other, crowd the context window, and break behavior that used to work. The one documented remedy, SkillProx, runs an offline audit that re-tests the agent with each instruction removed and permanently deletes the ones that do not pay for themselves. That audit is expensive, judges each instruction in isolation, and destroys rules that may matter for inputs the validation set never covered. Cortical circuits face a similar problem, since learning that strengthens whatever already fires tends to run away. They usually solve it without erasing memories. Matched inhibitory "negative images" hold a stored trace silent until context releases it, a step called disinhibition (Barron et al.).

We propose to give each learned instruction its own inhibitory gate, and to learn that gate from failure feedback using a cheap local balancing rule instead of leave-one-out re-execution. The gate records the contexts in which the instruction has misfired and suppresses it there. A per-query threshold rises and falls quickly so that the amount of instruction text shown to the agent stays near a fixed budget. When a new failure arrives, the optimizer first tries releasing a suppressed instruction and only writes new text if that does not fix it. The bet is that reversible, context-dependent suppression beats deletion on both cost and out-of-distribution retention, and that it beats plain relevance retrieval because it learns from harm, not only from topical similarity.

Core Claim

Instruction bloat in textual optimization is a stability problem, not only a compression problem. Ideas from homeostatic inhibitory plasticity give a concrete design for it with three parts: learned per-instruction inhibition that tracks harm, a fast sliding inclusion threshold, and disinhibition before new text is written. We claim this design matches or exceeds SkillProx's in-distribution accuracy, retains more out-of-distribution and earlier-task performance, and uses an order of magnitude fewer evaluation rollouts per consolidation step. A secondary, falsifiable claim speaks to Melcer et al. (2025), who found that prompt optimizers do about as well with deliberately wrong feedback as with correct feedback. Gate learning uses feedback in a narrow way: it assigns blame to a specific included instruction, not a whole-prompt rewrite. If gate learning is genuinely driven by feedback, corrupting that feedback should hurt it measurably.

Mechanism

The agent keeps a library of instruction units $u_i$, the atomic "knowledge units" in SkillProx's sense. Each unit has a relevance drive $e_i(x)$, which is the embedding similarity between query $x$ and the unit. Each unit also has an inhibitory memory: a small set of stored failure contexts plus an LLM-written one-line description of when the unit misfires. From this memory we compute $s_i(x) \in [0,1]$, the similarity of $x$ to the unit's misfire contexts. A unit is shown to the agent when

$$e_i(x) - w_i\, s_i(x) > \theta_t,$$

where $w_i \ge 0$ is the learned inhibitory weight and $\theta_t$ is a shared threshold. After each batch $t$, the threshold slides so that the mean included token mass $\bar{m}_t$ tracks a budget $B$:

$$\theta_{t+1} = \theta_t + \eta\,(\bar{m}_t - B).$$

This is the textual counterpart of a sliding plasticity threshold. Following the argument of Zenke et al. (2013) that homeostatic control must act faster than the positive-feedback learning it restrains, the threshold updates every batch rather than every audit epoch.

The inhibitory weights follow a balance rule in the spirit of inhibitory spike-timing plasticity, which adjusts inhibition to hold a ratio of excitation to inhibition rather than a fixed activity level (Froemke et al.; Hennequin et al.). For each failure, one judge-LLM call reads the trace and names which included units the agent followed and which were implicated in the error. An implicated unit's $w_i$ increases and the failure context is added to its inhibitory memory. Units followed in successful traces have $w_i$ decayed. The fixed point is each unit's precision when included reaching a target $\rho$. This costs one call per failure, whereas a leave-one-out audit costs $O(N)$ re-evaluations over a validation set.

The update step borrows from co-dependent plasticity, in which excitatory learning stays locked unless inhibition is lifted (Agnes and Vogels, 2024). On a failure, the optimizer first re-runs the query with the top suppressed-but-relevant units released. If that fixes the failure, the optimizer lowers those units' gates for that context and writes no new text. Only failures that disinhibition cannot fix reach the normal TextGrad-style critique-and-rewrite step, which adds a new unit. This is what keeps library growth in check.

Relation to Prior Work

The proposal reuses its basic machinery from existing work. The critique-and-rewrite step comes from TextGrad, which passes LLM critiques backward through a graph of text variables. The decomposition into knowledge units comes from SkillProx.

Two other papers motivate the problem. SkillProx shows that growth-only optimization degrades performance and that removing about 3% of a skill library lifted hard accuracy from 46% to 54%. That result is direct evidence that some instructions do harm. RiOT shows that keeping parent sentences by embedding similarity reduces drift. Its fusion is additive, though, and its thresholds are fixed hyperparameters.

Our method differs from SkillProx in three ways: it suppresses where SkillProx deletes, it assigns blame per failure where SkillProx re-executes, and its gating depends on context where SkillProx's audit is global. It differs from RiOT by having an adaptive threshold tied to a budget, and by being able to silence a unit actively rather than only preserve it.

FlowBot has the same runaway-growth issue at the level of workflow structure. We treat it as a later application, not a target here.

Melcer et al. act as a constraint. Their result warns that any gain may come from sampling many candidates and selecting on validation data rather than from the feedback itself, so the experiments must separate those two sources. Finally, Habenschuss et al. (2012) show that a homeostatic rate constraint can turn a global normalization problem into a set of local updates. That result is the theoretical reason to expect a budget-tracking threshold to replace a global audit at all.

Research Program

We will implement the gated library on top of the SkillProx forward loop and keep its diagnostician, batch rollback, and backbone (Qwen3.6-27B) unchanged. Only the consolidation and inclusion steps are swapped, so any difference can be attributed to them.

The program has three stages. The first measures accuracy, library size, included tokens per query, and LLM calls per consolidation step on SkillProx's in-distribution and out-of-distribution suites. The second builds a sequential setting that targets forgetting. It optimizes one library across the five tasks in RiOT's suite in sequence: GSM8K, LogiQA 2.0, StrategyQA, Object Counting, and Date Understanding. After each stage it measures accuracy on all earlier tasks. Deletion should do worst here, and suppression should help most. The third runs a mechanism analysis. It tracks the trajectories of $w_i$ and $\theta_t$, how often the disinhibition-first step resolves failures, and whether the threshold's update timescale matters. Our timescale prediction comes from Zenke et al.: slowing the threshold update to once per epoch should produce oscillating bloat and accuracy dips.

Baselines

The naive reference point is growth-only textual gradient descent: a TextGrad-style loop that appends every accepted patch with no consolidation. It shows how much bloat and drift there is to fix. On GSM8K, RiOT reports TextGrad at 76.6% accuracy and at 73.2% weighted average across its five-benchmark suite. We will rerun it under our backbone and not quote those numbers as directly comparable.

The strongest existing method is SkillProx, which uses forward edits with rollback plus a backward leave-one-out audit. On SpreadsheetBench Verified with Qwen3.6-27B, SkillProx reports 54.5% accuracy, against 50.0% for SkillGrad and 36.7% for human-curated skills. It also reports a 3.0-point average gain over SkillGrad on the WikiTQ and HiTab transfer tasks; the file gives no per-dataset absolute numbers for WikiTQ or HiTab. We will run SkillProx's own pipeline with the same backbone, the same training and validation splits, and the same number of optimization rounds. We will also give it the same total LLM-call budget, so that if our method saves calls, SkillProx may spend the difference on extra audits. Beating SkillProx means matching it within noise on SpreadsheetBench Verified while scoring higher on WikiTQ and HiTab and on retention of earlier tasks in the sequential setting, at lower consolidation cost. Being cheaper but worse on retention would not count.

RiOT is the strongest drift-control baseline for the reasoning suite. It reports 81.2% on GSM8K and a 77.2% weighted average, against 74.5% for DSPy. We will run it with its published thresholds and tree width, under our backbone and an equal call budget.

The most dangerous baseline is pure relevance retrieval: the same library, top-$k$ units by embedding similarity, with no learned inhibition, with $k$ tuned on validation data to match our token budget. No reported result was found on Lacuna for this baseline on these benchmarks.

Four ablations isolate the key ingredients. The first removes the inhibitory term, setting $w_i = 0$. The second fixes $\theta$ instead of letting it slide. The third removes the disinhibition-first step. The fourth replaces suppression with hard deletion once $w_i$ crosses a cutoff, which is the ablation most directly testing "suppress, don't delete."

Why not just…?

Why not just generate many candidate prompts and keep the one that scores best on validation? Melcer et al. found that much of what prompt optimizers gain comes from exactly this, which makes it a serious competitor. However, it does nothing about growth over many rounds, and their stress test consumed over 5.7 billion tokens and $42,536 in API fees. We include a best-of-$K$ selection arm at matched call budget. If it equals our method on retention and out-of-distribution accuracy, the inhibitory machinery adds nothing, and we will report that.

Why not just run SkillProx's leave-one-out audit more often? The audit costs $O(N)$ rollouts per pass. SkillProx itself states that the audit misses pairs of instructions that are harmful only together, and deleting a unit discards it for inputs the validation set lacks. The deletion ablation and the sequential-task experiment test this directly. If hard deletion retains earlier tasks as well as suppression does, the reversibility argument fails.

Why not just retrieve the most relevant instructions per query? This is the real threat, because retrieval already solves context bloat. Our claim is narrower: similarity alone cannot tell a relevant-but-harmful rule from a relevant-but-helpful one, and the learned inhibition can. The no-inhibition ablation, with $k$ tuned to the same token budget, settles this. The prediction is that the gap appears specifically on queries near stored misfire contexts. We will report accuracy on that slice separately, and if the gap is absent there we will treat the inhibitory term as unnecessary.

Why not just cap prompt length? A hard cap forces a choice about which units to drop, and making that choice is the whole problem. A fixed-$\theta$ arm and a truncate-to-budget arm show whether the adaptive threshold matters beyond the cap itself.

Decisive Checks

Three results would decide the proposal. First, on the sequential five-task run, our method must keep more earlier-task accuracy than SkillProx and hard deletion at the same final library budget. Second, on SpreadsheetBench Verified, it must at least match SkillProx's reported 54.5% while using fewer consolidation rollouts, and it must outperform tuned top-$k$ retrieval on the near-misfire slice. Third, following Melcer et al.'s protocol on BBEH Web of Lies and GPQA Diamond, we will corrupt the judge's blame assignments. If accuracy and retention under corrupted blame stay indistinguishable from accuracy under correct blame, the gains are not coming from feedback-driven inhibition, and we will treat the mechanism as refuted rather than reinterpreting it.