@skills: ATTENTION IS ALL YOU HAVE | Li Yin et al. | ResearchPod

Transcript: @skills: ATTENTION IS ALL YOU HAVE

Alex: Welcome to another episode of ResearchPod. Today we're looking at a position paper called "@skills: Attention Is All You Have," which takes aim at a structural bottleneck in how AI agents manage procedural knowledge.

Sam: The title's a riff on the transformer paper, but the argument sounds more architectural than algorithmic. What's the core claim?

Alex: The authors argue that the current skill-installation paradigm conflates three logically distinct operations — content delivery, persistence, and auto-triggering — into a single "install" action. And that conflation has a concrete cost: everything gets forced into the agent's resident prompt, which is a strictly bounded attention budget.

Sam: So the problem isn't the number of available skills per se, it's that the delivery mechanism treats context like it's free.

Alex: Exactly. The authors describe it as a "standing tax." Every installed skill occupies resident tokens whether or not it's relevant to the current task. And because auto-triggering is unreliable beyond a fairly small number of slots, you end up in a situation where tens of thousands of nominally available skills are functionally ignored — not because the agent can't use them, but because the architecture never surfaces them.

Sam: That's an interesting framing. It's less about capability and more about retrieval failure caused by prompt saturation.

Alex: Right. And the failure mode is subtle. It's not that the agent crashes — it's that reasoning quality degrades as the resident prompt fills up. Instruction dilution. The signal-to-noise ratio in the context window drops, and the agent's ability to follow task-specific instructions erodes.

Sam: So what's their proposed fix?

Alex: They introduce a tiered delivery model built around simple suffixes. A reference pulls skill content on-demand into the working context without any residency cost. A save vendors the skill locally for repeated use. And an install reserves true residency — and the auto-triggering that comes with it — for the small class of skills that genuinely need to fire unprompted. The key move is making those three operations explicit and separable rather than bundled.

Sam: The library analogy writes itself here. You maintain a full catalog, but you only pull a book off the shelf when you actually need it — rather than stacking every book on the desk at the start of every session.

Alex: That's essentially it. And by moving to a file-tree-based reference protocol, they sidestep the need for global manifests or heavyweight skill registries. The agent can navigate to what it needs, when it needs it, without the overhead of maintaining everything in working memory simultaneously.

@skills: ATTENTION IS ALL YOU HAVE

Li Yin, Zhi Li, Zhan Shi, Haoran Zhang, Haebin Seong, Zhangyang (Atlas) Wang

Aug 12, 2026·4:37·arxiv·Original Paper

Agent Skills@skills ProtocolPrompt ResidencyProcedural Knowledge@skillsResident Prompt

Listen

5 min

Briefing

The Problem with Current Agent Skills

Coding agents currently deliver procedural knowledge—skills—by installing them into a system directory. Once installed, a skill's description is permanently injected into the agent's system prompt. This creates a significant problem: the agent's attention budget is strictly limited, and the 56,804 publicly available skills are forced to compete for fewer than 100 reliable trigger slots. This leads to "trigger-engineering," where authors pad descriptions with complex instructions to ensure their skill fires, which in turn increases prompt bloat and degrades overall model reasoning performance.

The @skills Protocol

@skills proposes an open protocol that decouples the three functions bundled into current installations: content, persistence, and auto-triggering. By separating these, the protocol introduces three distinct tiers of delivery:

Reference (Tier 1): Skills are fetched at the point of use and injected into the context only when needed. This costs zero resident tokens and serves the long tail of the 56,804 available skills.
Saved (Tier 2): Skills are vendored into a project's git-tracked tree. They are available for autocomplete and search but do not occupy the prompt, making them ideal for team workflows like deployment runbooks.
Installed (Tier 3): Only the most essential skills—such as security guardrails—are kept resident in the prompt, preserving the limited attention budget for tasks that must fire implicitly.

Why It Matters

This protocol transforms skills from a commitment into a decision. Because referencing a skill costs nothing that persists, users can try new capabilities without the overhead of managing installations across multiple agents or machines. For teams, it provides a unified way to share private workflows that are version-controlled and reviewed like code. By moving away from an install-only lifecycle, the ecosystem can scale to support tens of thousands of skills without hitting the hard limits of the model's attention budget.

Key Terms and Definitions

Agent Skill — A directory containing a SKILL.md file that provides procedural knowledge or instructions to an AI agent.
Resident Text — Text that occupies the agent's system prompt on every message, consuming a portion of the limited attention budget.
Auto-triggering — The mechanism where an agent automatically loads and executes a skill based on a probabilistic match between the user's request and the skill's description.
Vendoring — The practice of copying a skill into a project's local git-tracked directory, allowing it to be owned and adapted by the team rather than relying on an upstream source.
Leaf Rule — A resolution constraint where a folder containing a SKILL.md file is treated as a skill, preventing nested repositories from being incorrectly parsed as multiple skills.

Abstract

There are 56,804 public agent skills today, and teams write many more privately. The dominant delivery model is installation: once installed, a skill's description remains in the system prompt, competing for fewer than 100 reliable trigger slots. This leaves the long tail with no practical path to use and forces teams' own playbooks to compete for the same scarce space. We observe that installation bundles three separable functions: content, persistence, and automatic triggering. Only the last requires prompt residency. We therefore propose @skills, an open protocol that separates them. A path addresses any skill, subtree, or collection, and reading a skill is sufficient to use it, so nothing is installed or made resident. The operation vendors a copy at the same path into a project's Git-tracked tree for adaptation and ownership. The operation adds one .gitignore-style line, the only element that costs prompt residency. A directory is a menu, making bundles ordinary directories rather than all-or-nothing units. The protocol requires no manifest, lockfile, or registration, and SKILL.md remains unchanged. @skills is additive, ships as an installable package, and turns any agent that can read files and run commands into a client through a single instruction file. Its open specification is at https://github.com/SylphAI-Inc/atskills and it is implemented in the AdaL CLI at https://adalagent.ai . Because paths address skills well but cannot find them, the protocol is paired with a free hub at https://atskills.one for corpus-wide search and ranking, repository-free hosting, private and team collections, and one-screen authoring. The hub is optional: gh: and local paths resolve without it, and indexed GitHub skills retain their gh: identities. Install less, use more.

@skills: ATTENTION IS ALL YOU HAVE: Research Paper Podcast