The regression tax: why loading LLM agents with skills can backfire

Every LLM agent builder knows the drill: the agent fails at a task, so you add a skill, a short script, a validation rule, a standard operating procedure encoded as a prompt. Average scores go up. Problem solved, right?

A new paper suggests the answer is more complicated. 'The Regression Tax: Decomposing Why Skills Help and Hurt LLM Agents', posted to arXiv on July 24, 2026, compares agents with and without skills across nearly 6,000 runs on two office automation benchmarks and three model harness stacks. The headline finding is that skills cause failures too: tasks the agent handled fine without a skill suddenly break when a skill sits in context. The same failure pattern has emerged in production deployments, where even well-tested agents stall unexpectedly, as the planning trap analysis has shown.

The authors call these failures 'regressions' and argue that the net improvement most papers report hides a deeper truth: the best performing skills outperform others primarily by regressing less, not by gaining more.

What is a regression tax?

The paper splits task outcomes into four categories: solved without and without skills, solved with skills but not without (a gain), failed with skills but not without (a regression), and failed both ways (a residual failure). Most evaluations collapse gains and regressions into a single net improvement number, which the authors say masks the cost of adding skills. The hidden cost of context bloat and skill interference is a theme echoed in research on working memory limits in agentic workflows.

When they looked at what actually caused regressions, they identified three mechanisms.

The three regression modes

Skill description osmosis. A skill changes an agent's behavior simply by being present in context, even when it is never invoked. The agent reads a skill about formatting output and starts reformatting inputs too, or reads a skill about error handling and becomes more cautious in ways that break previously working workflows.

Grounding displacement. A skill's prescribed procedure overrides how the agent interprets its inputs. Instead of looking at the actual screen, the agent follows a checklist from the skill that doesn't match the current state. The agent stops seeing what is there and starts seeing what the skill tells it to see.

Verification displacement. The procedure supplied by a skill suppresses checks the agent would otherwise perform on its outputs. An agent that naturally double-checks a file path stops double-checking because the skill says 'run this command' and the agent trusts the skill more than its own verification habits.

Gains come from elsewhere

The paper does not argue that skills are useless. Gains do occur, but they are concentrated in specific situations. The more interesting pattern emerges from the persistent failures, tasks that fail both with and without skills. When the authors analyzed those failure traces, they found that existing skills overemphasize procedural guidance, which is the stage least often responsible for failure. The real bottlenecks are grounding (understanding the current state) and verification (checking that the output is correct). This mirrors findings from enterprise migration tasks, where agents fail because they cannot tell when the job is actually done, as documented in ScarfBench's failure analysis.

After correcting evaluation artifacts and studying traces, the authors report that many regressions and persistent failures are recoverable through better grounding and verification, not through better procedural skills.

Part of a wider shift

The paper joins a growing body of work rethinking how agent skills are evaluated and built. A June 2026 study comparing GUI and CLI agents found that GUI agents outperform skill-mediated CLI agents when both get identical goals and verifiers, suggesting that the skill interface itself introduces fragility. Another paper, SkillCoach (July 2026), proposes process rubrics to evaluate skill-use beyond final accuracy, separating skill selection, following, composition, and reflection, dimensions the regression paper echoes. And EvoPolicyGym (also July 2026) benchmarks how agents iteratively improve policies, with GPT-5.5 topping its suite, hinting that iterative refinement of skills may eventually reduce the regression tax. The broader agent orchestration landscape is also evolving toward parallel agents that require careful coordination, which adds another dimension to the skill evaluation problem.

None of this means agents should stop using skills. It means the naive approach, drop a skill into context and watch the average number go up, is no longer good enough. The next generation of agent frameworks will need to measure regressions, not just net improvements, and invest in grounding and verification infrastructure rather than simply stacking more procedural rules.

As the paper puts it, reliability depends more on grounding and verification than on procedural skill choice. That is a hard lesson for the skill-first paradigm, but one the evidence now demands.