Skills an agent writes for itself are 8 to 11 points worse than no skill at all

This one falsifies an assumption a lot of this year's agent tooling is built on, mine included.

The paper is WER (Write, Execute, Refine), arXiv 2608.17587, published 2026-08-18. It opens with a measurement rather than a method: skills that an agent authors for itself perform 8 to 11 points worse than running the same agent with no skill loaded. Not marginally worse. Worse than the empty baseline. (arXiv)

The interpretation the authors draw is that following procedural guidance and authoring procedural guidance are separate capabilities, and being good at the first tells you nothing about the second. A model that executes a well-written skill flawlessly will happily write a skill that actively degrades its own performance, and it has no way to notice.

Think about what that breaks. The self-improving agent loop, where the agent finishes a task, reflects on what it learned, and writes a skill file for next time, is the default architecture in about half the agent memory products shipping right now. If the written artifact is net-negative, the loop isn't self-improvement. It's self-poisoning with extra steps.

WER's fix is structural and I like it a lot. Freeze the executor. Train a separate Skill Optimizer that never executes anything. Feed it matched pairs of successful and failed trajectories from a programmatic verifier, so the refinement signal is grounded in what actually happened rather than in the model's own account of what it thinks happened. The results: +7.80 Pass@1 on BFCL v4 multi-turn and +3.85 on tau2-bench over the no-skill baseline. And a purpose-trained 4B optimizer hits 76.63% on BFCL v4, beating every off-the-shelf general-purpose model used as a skill optimizer, including the big ones.

A 4B model beating frontier models at writing skills, while being useless at executing them, is the cleanest possible demonstration that these are different jobs.

This converges with SkillGate (arXiv 2608.18852), which names a related failure it calls selector credit starvation. In long-horizon agents, the tokens that name which skill to load receive a vanishing share of the training loss signal, and the credit assignment gets worse as trajectories get longer. Splitting the loss into two disjoint channels, outcome credit for execution tokens and an action-local advantage that only rewards skill-naming tokens when the single skill read was correct, took a 9B policy from 40.8% to 53.2% across five agentic benchmarks. (arXiv)

Two papers, two days apart, both saying the same thing from different angles: the selection and authoring layer of your skill system is undertrained relative to the execution layer, and it fails silently.

What I'd do tomorrow: stop letting your agent write its own skill files unsupervised. If you have a reflection loop that appends to a skills directory, put a verifier in front of it, an actual pass/fail check on a held-out task, and only commit the skill if it beats the no-skill baseline. That's the whole finding. Measure against empty, not against your previous skill. Empty is a real competitor and it's currently winning.