ADK Skills — The Big Picture

What a Skill is

ADK's own definition: a self-contained unit of functionality that an ADK agent can use to perform a specific task.

Concretely: a Skill is a directory (or an inline definition) containing:

• A SKILL.md file with frontmatter describing what the skill does.
• An instruction block loaded into the model context when the skill is triggered.
• A resources folder of reference material, templates, and executable scripts.

Why not just tools?

Tools give an agent capabilities. Skills give an agent knowledge about when and how to use those capabilities. A tool tells the LLM "I can call the accounting API." A skill tells the LLM "When the user asks about expense categorization, load these classification rules and then call the API this way."

Skills solve the problem that as your agent grows, its main instruction becomes a wall of text. Skills let you factor that wall into on-demand chunks.

The three-level structure

Every Skill is stratified into three loading levels:

• L1 — Metadata: just the frontmatter in SKILL.md. Always loaded, cheap. Enables discovery.
• L2 — Instructions: main instruction body. Loaded when the skill is triggered.
• L3 — Resources: templates, examples, scripts. Loaded only when the instruction explicitly references them.

This tiered loading is the mechanism that keeps context windows small even as your skill library grows.

Inline vs filesystem

# Inline (Python)
from adk import models

expense_skill = models.Skill(
    name="expense-categorization",
    frontmatter={"description": "Categorize expenses per company policy"},
    instructions="When the user submits an expense, ...",
)

# Filesystem (Python)
from adk.skills import load_skill_from_dir
expense_skill = load_skill_from_dir("./skills/expense-categorization")

Inline for prototyping, filesystem for anything you'll iterate on or share.

What it changes about your agent design

Adopting Skills shifts your mental model from one big agent with one long instruction to a coordinator + a growing library of triggered skills. Three concrete effects:

• Instructions stay short — the coordinator's system prompt only names what skills exist.
• Skills evolve independently — versioned, tested, and deployed on their own cadence.
• Cost per turn drops — you're not paying to keep unrelated instructions in context.

When Skills are the wrong choice

Skills add complexity. Don't use them if:

• Your agent only does one thing — a single instruction is simpler.
• You're prototyping — inline skills are fine, but filesystem skills add overhead too early.
• Your skill would fit in ~200 tokens of instruction — the L1/L2/L3 machinery isn't worth it.

Skills shine when you have five or more distinct capabilities and want to factor them cleanly.