{"slug": "agent-skills-the-composition-cliff", "title": "Agent Skills: The Composition Cliff", "summary": "Adding a single skill to an LLM agent reliably improves task performance, but by the time a fourth skill is active, the cumulative gain shrinks to a fraction of what two skills produced, according to the SkillsBench benchmark covering 84 tasks. The agentskills.io specification lacks dependency declaration, conflict signaling, and composition ordering, leading to a 'composition cliff' where skill benefit drops by 68% from two to four or more skills. Three mechanisms drive this: 'Lost in the Middle' attention effects, token accumulation crossing a threshold, and skills written by models performing below baseline.", "body_md": "A single skill added to an LLM agent reliably improves task performance. A second skill helps further. However, by the time a fourth skill is active, the cumulative gain has shrunk to a fraction of what two skills produced. This pattern holds across 84 benchmark tasks and a format now adopted across multiple frontier model providers.¹\n\nThe ecosystem is growing in the opposite direction. The number of skills being authored and published is growing rapidly, while the format governing how those skills are combined has not grown to match. The agentskills.io specification defines the SKILL.md format now used across Claude, Codex, Cursor, and two dozen other platforms,¹² but there is no dependency declaration, no conflict signaling, and no composition ordering mechanism. Skills are authored as standalone files and combined by runtimes with no formal information about how those skills interact.\n\nWhen instructions conflict or cancel each other out, there is nothing in the format to prevent it.\n\nThe composition cliff is the predictable result.\n\nagentskills.io specification¹⁰ defines its structure: a YAML header (called frontmatter) with six defined fields — name, description, license, compatibility, a free-form metadata block, and allowed-tools — followed by a Markdown body. The body contains natural language instructions that a runtime injects into the model's context, typically the system prompt, to direct behavior toward a specific capability: a code formatting convention, a git workflow, domain terminology, a structured reasoning approach.\n\nSkillsBench, a benchmark covering 84 tasks drawn from real agent deployments,¹ evaluates whether models follow skill instructions and whether following those instructions improves task outcomes.² It ranges from software engineering to healthcare, tests both frontier and smaller models, and distinguishes curated human-authored skills from skills written by the model itself.\n\nThree findings hold consistently across model families.\n\n**Skills can hurt as well as help.** Across 84 tested tasks, skills improve outcomes on 68 but worsen them on 16. Roughly one in five skill activations produces results below the baseline with no skills at all.¹ This is a systematic pattern correlated with instruction complexity and skill overlap.\n\n**Skill benefit depends heavily on model size. **Claude Haiku with skills achieves around 28% task success. Claude Opus without skills achieves 22%.¹ A smaller model with good skills outperforms a larger model running unaided. Skills fill behavioral gaps that are explicit in smaller models and latent in larger ones: present in the larger model’s training, but not reliably activated without explicit instruction.\n\n**Skills written by models do not work.** When models author the skills they will later consume, those skills perform on average below the no-skill baseline.¹ The benchmark authors note these tend toward two failure modes: too abstract to provide actionable guidance, or too specific to generalize across task variants. The mechanism is not understood.\n\nThe drop from 18.6 percentage points of gain with two to three skills to 5.9 percentage points with four or more represents a 68% reduction in what each additional skill contributes.¹ That magnitude is steep enough to constitute a discontinuity rather than a gradient.\n\nThree mechanisms drive it, each compounding the others.\n\n**Skills in the middle of context get less attention.** The “Lost in the Middle” research documented across multiple model families that information at the beginning and end of a context window is retrieved with significantly higher accuracy than information in the middle.³ For a set of skills injected into a system prompt, only those at the edges receive consistent model attention. Skills positioned in the middle are processed less reliably, and the effect worsens as total context length grows.\n\n**Token accumulation crosses a threshold.** Each skill contributes tokens to the system prompt, and every additional token incurs attention dilution alongside the raw token count.¹⁴ Reasoning reliability begins declining at roughly 3,000 tokens of instruction content.¹² A set of four skills averaging 400 tokens each approaches this threshold before any content specific to the task is added.\n\n**Non-adherence rates multiply rather than add.** Each skill carries its own rate of non-adherence: the fraction of the time the model partially or fully ignores it. When multiple skills are active simultaneously, these rates do not add; they multiply. If each of four skills is followed 90% of the time in isolation, all four are followed simultaneously in only 66% of cases (0.9⁴).¹³ At six skills: 53%. At ten: 35%. This happens because a model processes all instructions together in a single pass, with no mechanism that resolves conflicts between them before a response is generated.\n\nThe ScaledIF benchmark⁴ tested this directly by measuring how often instructions conflict as more are added. ScaledIF operates at the prompt level, stacking formatting and content instructions rather than agent skills, but the transfer is direct: when a skill is triggered, its instructions are injected into the same context window the model processes in a single pass. With 2 active instructions, conflicts are rare. With 10, they are nearly unavoidable. More instructions produce more conflicts, and more conflicts produce lower task success.\n\nA SKILL.md file’s YAML header (the structured block at the top of the file that declares the skill’s name, description, and other properties) carries no information a runtime can use to make composition decisions.¹⁰\n\nThere is no mechanism for a skill to declare which behavioral dimensions it modifies. Two skills that both alter output formatting cannot signal this overlap to each other or to the assembling runtime, so no conflict is detectable before execution. There is no dependency declaration. For instance, a runtime loading a code review skill has no way to know whether it should also load a code formatting skill, or whether those two will conflict if loaded together. Dependencies exist, but are buried in natural language rather than surfaced in the header.\n\nThere is no ordering convention. Because a model pays more attention to instructions at the edges of a context block,³ injection order directly determines which skills receive the most reliable model attention. Yet the format gives no guidance on sequencing, leaving each platform that has adopted it to resolve injection order independently.¹¹ Two platforms loading identical skills in different sequences will get different behavior, for a reason the “Lost in the Middle” findings make entirely predictable.\n\nMicrosoft’s **Agent Package Manager (APM)** implements a dependency manifest alongside SKILL.md.⁵ APM manifests declare tool dependencies, specify version constraints, and support resolution with lockfiles. The analogy to npm is explicit: APM solves the same class of problem for agent skills that npm solved for JavaScript packages, ensuring that when a skill is loaded, the tools it needs are available.\n\nAPM solves the same problem npm solved for JavaScript: making sure everything a package needs is available when it runs. But npm has never prevented two packages from behaving badly together, and APM has the same blind spot. Getting the right tools loaded is a different problem from getting skills that don’t contradict each other.\n\nThe **DSPy framework, **developed at Stanford and collaborating universities, takes a different approach.⁶ Rather than managing dependencies, it treats prompt writing as an optimization problem. A developer describes what they want in abstract terms (inputs, outputs, and a scoring function) and DSPy automatically experiments with prompt variations to find the wording that maximizes the scoring function, without manual tuning. DSPy’s documentation reports an informal run on a banking intent classification task in which a DSPy optimizer raised a GPT-4o-mini pipeline from roughly 66% to 87% accuracy.⁷\n\nThe limitation is that DSPy requires a defined scoring function and a set of representative examples to optimize against. Most skill authors have neither, and a pipeline tuned on one task distribution can behave unpredictably outside it. For instance, a prompt tuned to classify banking queries may give unpredictable results when the same agent encounters a refund request it wasn’t trained on.\n\nThe** CUA-Skill Agent** research shows that explicitly telling a skill what conditions must be true before it runs, and what it should guarantee afterward, produces meaningfully better results on complex sequential tasks than skills written in unstructured natural language (57.5% success vs. substantially lower baselines).⁸ This is the closest existing work to a formal interface mechanism for skills, but it requires substantially more authoring effort than the current SKILL.md format supports.\n\nThe compounding non-adherence problem has no fix within the current paradigm. Individual skill adherence varies from 72% to 96% across model and skill type;¹ the joint probability that all active skills are satisfied simultaneously degrades with each skill added. Keeping the number of simultaneously active skills small is the only validated mitigation the data supports. The benchmark suggests a practical ceiling around three before degradation becomes the dominant effect, regardless of skill quality.¹ Under more realistic deployment conditions, where agents must retrieve skills from a large collection rather than receive curated skills directly, performance approaches no-skill baselines entirely.¹⁵\n\nDetecting interference before execution requires empirical testing rather than static analysis. There is no published method for predicting from skill content alone whether two skills will conflict. As skill libraries grow, the testing burden grows quadratically: every new skill must in principle be evaluated in combination with every existing skill it might be composed with.\n\nThe 68% drop between the two-to-three skill peak and the four-plus floor is not a gap between well-written and poorly-written skills. It is a gap between isolated and composed execution. Anyone who tests skills individually and deploys them in combination is measuring two different conditions.\n\nSkill authoring cannot currently be automated.¹ Models can follow good skills reliably. They cannot write them reliably. That asymmetry defines the actual shape of the scaling challenge: not inference capacity, but authoring capacity.\n\n*Cover image generated with ChatGPT Images 2.0, refined in Figma. All other illustrations are original designs created in Figma.*\n\n¹ Li, Xiangyi, Wenbo Chen, Yimin Liu, et al. “SkillsBench: Benchmarking How Well Agent Skills Work Across Diverse Tasks.” [arXiv:2602.12670](https://arxiv.org/abs/2602.12670) (Feb. 2025).\n\nCompanion survey: Xu, Renjun & Yang Yan. “Agent Skills for Large Language Models: Architecture, Acquisition, Security, and the Path Forward.” [arXiv:2602.12430](https://arxiv.org/abs/2602.12430).\n\n² Models tested: Claude Opus 4.5, Claude Haiku 4.5, GPT-5.2, Gemini 3 Flash; temperature 0. Domains: software engineering, data analysis, content creation, customer service, healthcare.\n\n³ Liu et al. “Lost in the Middle: How Language Models Use Long Contexts.” *TACL* 12 (2024): 157–173. [arXiv:2307.03172](https://arxiv.org/abs/2307.03172).\n\n⁴ Elder, Ben, Evelyn Duesterwald, and Vinod Muthusamy. “Boosting Instruction Following at Scale.” [arXiv:2510.14842](https://arxiv.org/abs/2510.14842) .\n\n⁵ Microsoft Agent Package Manager. [https://github.com/microsoft/apm](https://github.com/microsoft/apm)\n\n⁶ Khattab, Omar, Arnav Singhvi, Paridhi Maheshwari, et al. “DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines.” arXiv:2310.03714. [https://dspy.ai](https://dspy.ai)\n\n⁷ See DSPy documentation, “Optimizers,” section “How do I use an optimizer?”, under the “Optimizing weights for Classification” tab ([https://dspy.ai/learn/optimization/optimizers/#how-do-i-use-an-optimizer](https://dspy.ai/learn/optimization/optimizers/#how-do-i-use-an-optimizer)). The figure is described in the documentation as an “informal run” on DSPy 2.5.29 using the Banking77 dataset, and should be read as illustrative rather than as a controlled benchmark.\n\n⁸ Chen, Tianyi, Yinheng Li, Michael Solodko, et al. “CUA-Skill: Develop Skills for Computer Using Agent.” [arXiv:2601.21123](https://arxiv.org/html/2601.21123v2).\n\n¹⁰ The agentskills.io open specification is available at [https://agentskills.io/specification.md.](https://agentskills.io/specification.md.) The six defined YAML frontmatter fields are name, description, license, compatibility, metadata , and allowed-tools .\n\n¹¹ See Xu & Yan (arXiv:2602.12430). Within four months of Anthropic’s October 2025 launch, structurally identical architectures were independently adopted by other frontier model providers; the anthropics/skills repository had accumulated over 128,000 GitHub stars by May 2026 with partner-built skills from Atlassian, Figma, Canva, Stripe, and Notion. Includes Claude Code, Codex CLI, Gemini CLI, 20+ others.\n\n¹² Levy, Jacoby & Goldberg. “Same Task, More Tokens: the Impact of Input Length on the Reasoning Performance of Large Language Models” *ACL 2024*, pp. 15339–15353. [arXiv:2402.14848](https://arxiv.org/abs/2402.14848). Degradation onset ~3,000 tokens.\n\n¹³ Illustrative rate; see Li et al. ([arXiv:2602.12670](https://arxiv.org/abs/2602.12670)) for empirical range of 72–96%. At 85% individual adherence, four-skill joint probability: 52%.\n\n¹⁴ Gao, Yudong, Zongjie Li, Yuanyuanyuan, et al. “SkillReducer: Optimizing LLM Agent Skills for Token Efficiency.” [arXiv:2603.29919](https://arxiv.org/abs/2603.29919).\n\n¹⁵ Liu, Yujian, Jiabao Ji, Li An, et al. “How Well Do Agentic Skills Work in the Wild: Benchmarking LLM Skill Usage in Realistic Settings.” [arXiv:2604.04323](https://arxiv.org/abs/2604.04323). 34,000-skill retrieval setting; gains approach no-skill baseline. Models: Claude Opus 4.6, Kimi K2.5, Qwen3.5–397B.\n\n[Agent Skills: The Composition Cliff](https://pub.towardsai.net/agent-skills-the-composition-cliff-0aa07efe97b3) was originally published in [Towards AI](https://pub.towardsai.net) on Medium, where people are continuing the conversation by highlighting and responding to this story.", "url": "https://wpnews.pro/news/agent-skills-the-composition-cliff", "canonical_source": "https://pub.towardsai.net/agent-skills-the-composition-cliff-0aa07efe97b3?source=rss----98111c9905da---4", "published_at": "2026-07-28 22:01:01+00:00", "updated_at": "2026-07-28 22:12:12.934867+00:00", "lang": "en", "topics": ["artificial-intelligence", "large-language-models", "ai-agents", "ai-research", "ai-tools"], "entities": ["agentskills.io", "SkillsBench", "Claude Haiku", "Claude Opus", "Codex", "Cursor"], "alternates": {"html": "https://wpnews.pro/news/agent-skills-the-composition-cliff", "markdown": "https://wpnews.pro/news/agent-skills-the-composition-cliff.md", "text": "https://wpnews.pro/news/agent-skills-the-composition-cliff.txt", "jsonld": "https://wpnews.pro/news/agent-skills-the-composition-cliff.jsonld"}}