@skills: Attention is all you have
The paper proposes @skills, an open protocol that decouples skill content, persistence, and automatic triggering to eliminate the need for permanent prompt installation, thereby enabling agents to dynamically access and adapt from a vast library of skills using only a single line of configuration.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine you are teaching a super-smart robot assistant how to do your homework, fix your code, or write a story. You have a massive library of "instruction manuals" (called skills) that tell the robot exactly how to handle specific tasks, like "how to deploy a website" or "how to review a code change." The problem is that the robot has a very limited amount of attention it can hold at once. Think of its attention like a tiny desk surface. If you try to put every single instruction manual on that desk at the start of the day, the desk gets cluttered, the robot gets confused, and it forgets the most important instructions because they are buried under a pile of papers it doesn't need right now. This is the core challenge of AI agents: how do you give them access to thousands of useful tools without overwhelming their tiny mental workspace?
This paper, titled @skills: Attention Is All You Have, tackles a specific headache in the world of AI agents. Currently, the only way to give an agent a new skill is to "install" it. Installing is like gluing a sticky note with the skill's description onto the robot's forehead. That note stays there forever, taking up space on its "desk" (the system prompt) every single time it talks to you, even if you never ask it to use that skill. The authors argue this is a terrible waste of the robot's limited attention. They propose a new, open protocol called @skills that changes the game: instead of gluing notes to the forehead, you simply point to the manual when you need it.
The Problem: The "Glued Note" Trap
The authors observed that there are already over 56,804 different skills published in the public world, but the current system is broken. Because every installed skill takes up a permanent spot in the robot's attention budget, and that budget is tiny (the authors estimate fewer than 100 reliable spots per agent), most of these skills can never be used. It's like having a library of 56,000 books but only being allowed to keep three on your nightstand. If you want to read a fourth, you have to throw one of the three away.
Worse, the current system forces a "one-size-fits-all" approach. To use a skill, you must install it, which means its description sits in the robot's mind constantly. This leads to three big problems:
- The Tax: Every time the robot speaks, it has to "pay" attention to every single installed skill description, even if it's irrelevant. This wastes energy and slows down reasoning.
- The Lottery: The robot has to guess which skill to use based on those tiny descriptions. If it guesses wrong, the skill stays silent, and the user never knows it was even there.
- The Junk Drawer: Because installing is the only way to keep a skill, people end up with a messy pile of skills they tried once and forgot about, cluttering the robot's mind forever.
The Solution: The "Magic Pointer" Protocol
The paper proposes @skills, a new way to handle these instructions that separates three things that were previously glued together: content (the instructions), persistence (keeping a copy), and triggering (making it fire automatically).
The authors introduce a simple, three-tier system that lets you choose the right tool for the job:
Tier 1: The Reference (The "Just-in-Time" Pointer)
This is for the long tail of skills you might need once or twice. Instead of installing them, you just type@skills:<path>when you need them. It's like asking a librarian to pull a specific book off the shelf only when you ask for it. The book appears right next to your question, the robot reads it, does the work, and then the book disappears. It costs zero permanent attention space. This allows all 56,000+ skills to be available without clogging the robot's brain.Tier 2: The Saved Copy (The "Vendored" Folder)
Sometimes you want to keep a copy of a skill in your own project folder (like a team's specific workflow) so you can edit it and own it. With @skills, you can "save" a skill to your project's.atskills/folder. This is like photocopying a recipe and putting it in your own cookbook. It stays in your project, but it still doesn't sit on the robot's forehead unless you explicitly ask for it. It's there for you to find and use, but it doesn't waste the robot's attention until you need it.Tier 3: The Installed Skill (The "Auto-Trigger" Exception)
This is the only tier that still uses the old "glued note" method, but it's reserved for the absolute essentials that must fire automatically without you asking, like security rules or formatting checks. Even here, the protocol is smarter: only the tiny title and description (the "frontmatter") stay on the robot's forehead. The rest of the instructions only load when the robot actually needs them.
How It Works in Real Life
The paper suggests that this protocol turns the messy "install everything" approach into a clean, file-based system.
- No more "Install" buttons: You don't install a skill; you just reference it by its path.
- No more hidden folders: Skills live in your project's file tree (like
.atskills/), so you can see them, edit them, and track changes with Git, just like code. - No more "Update" headaches: If you want a skill to stay current, you just "follow" it (one line in a config file). If you want to make it your own, you "save" it (a copy in your folder).
The authors also built a free "Hub" (a website) to help people find these skills, but the protocol is designed so you don't need the hub. You can point directly to skills on GitHub or your local computer. The hub is just a search engine, not a gatekeeper.
What the Paper Actually Found
The paper doesn't just propose a theory; it points to real-world data. The authors found that the current "install-only" model is structurally broken because it forces every skill to compete for a scarce resource (attention) that it often doesn't need. By separating the need to have a skill from the need to remember a skill, the @skills protocol allows agents to use the long tail of 56,000+ skills without breaking their brains.
The authors are confident that this approach solves the "attention budget" problem, but they note that the exact number of reliable "auto-trigger" slots (the Tier 3 limit) is an estimate based on existing research into how AI models lose focus over long conversations. They suggest that while the current system is a "junk drawer" where important skills get lost, the new three-tier system gives every skill a proper home: either in the cloud (Tier 1), in your project (Tier 2), or as a critical rule (Tier 3).
In short, the paper argues that we should stop treating AI skills like heavy furniture we have to glue to the wall, and start treating them like books we can pull off the shelf whenever we need them. The result is an agent that is lighter, faster, and capable of using a much wider world of knowledge without getting overwhelmed.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.