Primers • Agent Skills

• Overview
  • Definition
  • 1.2 Why skills exist in the first place
  • 1.3 Skills as procedural memory for agents
  • 1.4 The core idea: progressive disclosure
  • 1.5 Why progressive disclosure matters mathematically
  • 1.6 Why this design is strategically important
• References
  • Context Engineering Blogs/Guides
  • Prompting, in-context learning, and reasoning
  • Retrieval, long-context behavior, and compression
  • Tool use, acting, and execution
  • Memory, agents, and long-horizon systems
• Citation

Overview

Definition

• Agent Skills are best understood as small, portable capability packages for agents: each skill is a directory centered on a SKILL.md file, with optional scripts, references, and assets that an agent can load when needed rather than carrying all of that guidance in context all the time.
• The official format describes skills as an open, file-based way to give agents reusable instructions, resources, and domain-specific know-how, which makes them auditable, versionable, and easy to move across environments via ordinary developer workflows such as Git and shared folders.
• In other words, a skill is not a separate model, and not merely a tool call, but a structured packet of procedural knowledge that can include executable helpers and reference material.

1.2 Why skills exist in the first place

The motivating problem is that strong models are often capable but underspecified: they can reason, code, and call tools, yet they still lack the task-local expertise, organizational conventions, and up-to-date procedural guidance needed for reliable work in real settings. This is exactly the gap that skills are designed to fill. In modern agent architectures, the model increasingly behaves like a general-purpose executor over code, files, and tools, while the missing ingredient is expert workflow knowledge that tells it what good execution looks like in a particular domain. Closing the knowledge gap with agent skills frames this as the mismatch between static model knowledge and rapidly changing software practice, while Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks by Lewis et al. (2020) is relevant because it established the broader principle that parametric knowledge alone is often insufficient, and external context improves factual performance on knowledge-intensive tasks. (Google Developers Blog)

1.3 Skills as procedural memory for agents

A useful mental model is that tools provide actions, while skills provide situated procedure. A calculator API, shell, browser, or Python runtime tells the agent what it can do; a skill tells the agent when to do it, in what order, with what defaults, what edge cases to watch for, and what output standard to meet. This makes skills closer to procedural memory than to raw capability exposure. That framing fits naturally with Toolformer: Language Models Can Teach Themselves to Use Tools by Schick et al. (2023), which shows that language models benefit when they learn when and how to use tools, and with Gorilla: Large Language Model Connected with Massive APIs by Patil et al. (2023), which shows that access to tool documentation and retrieval improves API-call reliability under changing interfaces. Agent Skills occupy this layer of guidance between generic reasoning and concrete action execution. (arXiv)

1.4 The core idea: progressive disclosure

The defining systems idea behind Agent Skills is progressive disclosure. At startup, the agent loads only a compact catalog, typically just the skill name and description. It then activates the full SKILL.md only when the current task matches that description, and it loads heavier resources such as scripts or reference docs only if the instructions point to them. The official implementation guidance describes this as a three-tier loading strategy with roughly catalog, instructions, and resources as separate context layers, which is what lets an agent have many installed skills without paying the full token cost upfront. How to add skills support to your agent, What are skills?, and Optimizing skill descriptions all emphasize that the description is the trigger surface for this mechanism. Conceptually, this selective loading aligns with the broader agent pattern in ReAct: Synergizing Reasoning and Acting in Language Models by Yao et al. (2022), where effective agents interleave reasoning and external action instead of front-loading all information into one monolithic prompt. (arXiv)

1.5 Why progressive disclosure matters mathematically

The value proposition can be expressed as a simple context-budget argument. If an agent has (n) installed skills, and each full skill body would cost (s_i) tokens if loaded eagerly, then naive loading incurs

With progressive disclosure, the agent pays the catalog cost for all skills plus the full cost only for the activated subset (A):

1.6 Why this design is strategically important

The deeper significance of Agent Skills is architectural. They suggest that the path to better agents is not only bigger models or more tools, but cleaner separation between a general-purpose execution substrate and a portable layer of expert procedure. In that picture, one agent runtime can be reused across many domains, while skills encode the domain adaptation layer. That is why the format stresses portability, interoperability, and shareability across products and teams rather than binding knowledge to one vendor-specific harness. Overview presents skills as reusable packages for expertise and workflows across compatible agents, and Closing the knowledge gap with agent skills shows why this matters in fast-moving domains where documentation and best practices change faster than model weights can. (Agent Skills)

Say next for Section 2, which will cover the internal anatomy of a skill: SKILL.md, frontmatter, directory layout, scripts, references, assets, and the design logic behind each piece.

References

Context Engineering Blogs/Guides

• Effective context engineering for AI agents
• Writing effective tools for AI agents
• Building Effective AI Agents
• Context Engineering Guide
• How Long Contexts Fail
• How to Fix Your Context
• Prompt Engineering Guide

Prompting, in-context learning, and reasoning

• Language Models are Few-Shot Learners by Brown et al. (2020)
• Attention Is All You Need by Vaswani et al. (2017)
• Chain-of-Thought Prompting Elicits Reasoning in Large Language Models by Wei et al. (2022)
• Plan-and-Solve Prompting: Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models by Wang et al. (2023)
• Tree of Thoughts: Deliberate Problem Solving with Large Language Models by Yao et al. (2023)
• Self-Refine: Iterative Refinement with Self-Feedback by Madaan et al. (2023)
• Active Prompting with Chain-of-Thought for Large Language Models by Diao et al. (2023)
• Demystifying Chains, Trees, and Graphs of Thoughts by Besta et al. (2024)

Retrieval, long-context behavior, and compression

• Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks by Lewis et al. (2020)
• Lost in the Middle: How Language Models Use Long Contexts by Liu et al. (2024)
• LLMLingua: Compressing Prompts for Accelerated Inference of Large Language Models by Jiang et al. (2023)
• Context Rot: How Increasing Input Tokens Impacts LLM Performance by Hong et al. (2025)
• Found in the Middle: How Language Models Use Long Contexts Better via Plug-and-Play Positional Encoding by Zhang et al. (2024)

Tool use, acting, and execution

• ReAct: Synergizing Reasoning and Acting in Language Models by Yao et al. (2022)
• Toolformer: Language Models Can Teach Themselves to Use Tools by Schick et al. (2023)

Memory, agents, and long-horizon systems

• MemGPT: Towards LLMs as Operating Systems by Packer et al. (2023)
• Generative Agents: Interactive Simulacra of Human Behavior by Park et al. (2023)

Citation

If you found our work useful, please cite it as:

@article{Chadha2020DistilledContextEngineering,
  title   = {Context Engineering},
  author  = {Chadha, Aman},
  journal = {Distilled AI},
  year    = {2020},
  note    = {\url{https://aman.ai}}
}