When agent skills backfire, SkillProx prunes them like gradient descent

Add a skill to an LLM agent and performance usually ticks up. Do it a hundred times and the opposite can happen: the agent carries a library of procedures, warnings, and fixes, and a good share of them now drag it down. A preprint posted to arXiv on August 7, 2026 argues the field has been slow to treat this as the optimization problem it is.

SkillProx frames skill upkeep as textual gradient descent. The agent edits its own skills, measures the outcome, keeps what helps, and, crucially, deletes what doesn't. The paper reports an average accuracy gain of 3.0 percentage points over the strongest gradient-based baseline on in-distribution and out-of-distribution benchmarks, across multiple backbone LLMs.

Skills backfire more often than the averages show

The problem SkillProx targets is not hypothetical. A study on arXiv this summer, "The Regression Tax: Decomposing Why Skills Help and Hurt LLM Agents," compared agents with and without skills across nearly 6,000 runs on two office automation benchmarks and three model harness stacks. Its finding: skills produce regressions, tasks solved without a skill but failed with one, at a rate substantial enough that the best skill sets win mostly on that axis, per our earlier coverage of the regression tax. Average improvement hides a two-sided bookkeeping problem.

Existing skill-editing systems make it worse, the SkillProx authors argue. They diagnose failures without measuring outcomes, and they treat deletion as a generic edit operation. A skill that once helped can quietly turn into a distractor, and nothing in the loop forces the agent to notice.

A forward pass, a backward pass, and a rollback

SkillProx borrows the structure of proximal gradient methods, the optimization workhorse behind much of modern machine learning, and applies it in text space. The name is the point: an update is kept close to the previous skill unless the measured outcome justifies the move.

The forward stage works as a closed loop. The agent re-executes diagnosis-driven edits on the same task batch, measures what changed, and rolls back edits that produced regressions. Those outcomes feed the next round of diagnosis, so the agent is not guessing why a skill failed.

The backward stage is where the framework departs from its predecessors. The skill is decomposed into auditable knowledge units, and each unit's contribution is estimated with a frozen leave-one-out utility audit: remove it, re-run, and attribute the difference. A validation gate then decides whether a unit is consolidated, demoted, or removed. Deletion stops being a routine edit and becomes a dedicated mechanism for keeping accumulated knowledge honest.

A busy season for skill management

SkillProx lands in a crowded stretch of research on self-evolving agents. BAAI's AREX agents check their own homework instead of just searching longer; Alibaba's biggest model coded alone for 16 days. SkillCoach derives skill-grounded process rubrics from real rollouts to evaluate how well agents follow the skills they carry. OPID offers token-level supervision distilled on-policy, without the external skill memories that earlier variants depended on. SkillZip compresses bloated skill libraries by discovering reusable structure without running evaluations.

SkillProx's contribution points the other way. Rather than grading skill-use or shrinking files, it makes removal a first-class operation with the same rigor as addition. The composite objective it optimizes balances task loss against skill complexity, which is another way of saying an agent should not carry a skill that costs more than it returns.

The numbers, and the parts the paper doesn't cover

The reported 3.0 percentage point gain is measured against "the strongest gradient-based baseline," and component ablations attribute the results to both halves of the design: closed-loop diagnosis and proximal refinement. The preprint does not name the backbone LLMs it tested, so how well the mechanism transfers across model families is left for the full write-up and for replication.

Whether SkillProx's edits stay safe as libraries grow, and whether the leave-one-out audit scales to very large skill sets, are open questions the preprint does not resolve. It also says nothing about releasing the code.

The field is learning to treat agent memory as something to prune, not just pack. StructAgent rebuilds how agents track state on long tasks; SkillProx prunes the skills they carry. Skills are no longer just accumulated. They get managed, measured, and pruned, with some of the same discipline applied to weights. The agent that forgets deliberately may end up outperforming the one that remembers everything.