Your AI agent can observe directions. However can it write new ones? Agent Improvement Package (ADK)’s SkillToolset permits brokers to load area experience on demand. With the appropriate talent configuration, your agent can generate completely new experience at runtime. Whether or not you want a safety evaluation guidelines, a compliance audit, or a knowledge pipeline validator, the workflow is easy: generate it, load it, and use it.
The SkillToolset achieves this by progressive disclosure. This architectural sample permits brokers to load context exactly when it’s wanted, slightly than cramming hundreds of tokens right into a monolithic system immediate.
On this information, we’ll stroll by 4 sensible talent patterns:
- The inline guidelines: A primary, hardcoded talent implementation.
- The file-based talent: Loading exterior directions and assets.
- The exterior import: Using community-driven talent repositories.
- The talent manufacturing unit: A self-extending sample the place the agent writes new abilities on demand.
Every sample builds on the earlier one, culminating in an agent structure able to dynamically increasing its personal capabilities.
The issue with monolithic prompts
Most AI brokers get their area data immediately from the system immediate. Builders usually concatenate compliance guidelines, fashion guides, API references, and troubleshooting procedures into one huge instruction string.
This works fantastic when an agent solely has two or three capabilities. Nevertheless, if you scale as much as ten or extra duties, concatenating all of these directions into the system immediate prices hundreds of tokens on each LLM name. This occurs no matter whether or not the person’s particular question truly requires that data.
The Agent Abilities specification solves this by progressive disclosure. It breaks data loading into three distinct ranges:
- L1 Metadata (~100 tokens per talent): This contains simply the talent title and outline. It’s loaded at startup for all abilities and acts as a menu the agent scans to resolve what’s related.
- L2 Directions (<5,000 tokens): That is the total talent physique. It’s loaded by way of the API solely when the agent explicitly prompts a selected talent.
- L3 Assets (as wanted): These are exterior reference information like fashion guides or API specs. They’re loaded solely when the talent’s directions require them.
By utilizing this structure, an agent with 10 abilities begins every name with roughly 1,000 tokens of L1 metadata as an alternative of 10,000 tokens in a monolithic immediate. This interprets to roughly a 90% discount in baseline context utilization.
ADK implements this by the SkillToolset class, which auto-generates three instruments: list_skills (L1), load_skill (L2), and load_skill_resource (L3).
Sample 1: Inline abilities (the sticky word)
The only sample: a Python object with title, description, and directions, outlined immediately in your agent code. Finest for small, steady guidelines that hardly ever change.
# ADK Pseudocode: Sample 1: Inline Ability
seo_skill = fashions.Ability(
frontmatter=fashions.Frontmatter(
title="seo-checklist",
description="website positioning optimization guidelines for weblog posts. Covers title tags, meta descriptions, heading construction, and readability.",
),
directions=(
"When optimizing a weblog put up for website positioning, examine every merchandise:n"
"1. Title: 50-60 chars, main key phrase close to the startn"
"2. Meta description: 150-160 chars, features a call-to-actionn"
"3. Headings: H2/H3 hierarchy, key phrases in 2-3 headingsn"
"4. First paragraph: Main key phrase in first 100 wordsn"
"5. Pictures: Alt textual content with key phrases, compressed, descriptive namesn"
"Overview the content material in opposition to every merchandise and counsel enhancements."
),
)Python
The frontmatter fields turn into L1 metadata, which the LLM sees in each name. The directions turn into L2, loaded solely when the agent decides this talent is related. When requested “Overview my weblog put up for website positioning,” the agent masses this talent and applies every merchandise systematically.
Sample 2: File-based abilities (the reference binder)
Inline abilities work effectively for easy checklists. But when your talent wants reference paperwork (a mode information, an API spec), you want a listing.
A file-based talent lives in its personal listing with a SKILL.md file and non-obligatory subdirectories for references, property, and scripts. The SKILL.md begins with YAML frontmatter, adopted by Markdown directions.
abilities/blog-writer/
├── SKILL.md # L2: Directions
└── references/
└── style-guide.md # L3: Loaded on demandPlain textual content
This design splits data throughout two layers. The SKILL.md directions (L2) inform the agent what steps to observe. The references/style-guide.md file (L3) gives the detailed area data for every step. The agent masses the reference solely when its directions dictate it by way of the load_skill_resource instrument.
# ADK Pseudocode: Sample 2: File-Based mostly Ability
blog_writer_skill = load_skill_from_dir(
pathlib.Path(__file__).father or mother / "abilities" / "blog-writer"
)Python
File-based abilities make data reusable. Any agent that follows the agentskills.io spec can load the identical listing. However on this situation, you continue to wrote the SKILL.md your self.
Sample 3: Exterior abilities (the import)
Exterior abilities work precisely like file-based abilities. The one distinction is the place the listing got here from. As an alternative of writing your individual SKILL.md, you obtain one from a group repository like awesome-claude-skills and cargo it with the identical load_skill_from_dir name.
# ADK Pseudocode: Sample 3: Exterior Ability (similar API, totally different supply)
content_researcher_skill = load_skill_from_dir(
pathlib.Path(__file__).father or mother / "abilities" / "content-research-writer"
)Python
The code is an identical to Sample 2. The agentskills.io spec defines a common listing format, so load_skill_from_dir does not care whether or not you wrote the SKILL.md or downloaded it. Google publishes official ADK improvement abilities utilizing the identical format, installable by way of npx abilities add google/adk-docs -y -g.
These three patterns cowl abilities that exist already, ones you write or ones you discover. Sample 4 closes the loop: the agent writes its personal abilities.
A meta talent is a talent whose function is to generate new SKILL.md information. An agent outfitted with a meta talent turns into self-extending. It may possibly increase its personal capabilities with out human intervention by writing and loading new talent definitions at runtime.
The talent creator is an inline talent whose directions clarify the right way to write legitimate SKILL.md information. The hot button is the assets area. It embeds the agentskills.io spec specification itself and a working instance as L3 references. When requested to create a brand new talent, the agent reads these references and generates a spec-compliant SKILL.md.
# ADK Pseudocode: Sample 4: Meta Ability (The Ability Manufacturing unit)
skill_creator = fashions.Ability(
frontmatter=fashions.Frontmatter(
title="skill-creator",
description=(
"Creates new ADK-compatible talent definitions from necessities."
" Generates full SKILL.md information following the Agent Abilities"
" specification at agentskills.io."
),
),
directions=(
"When requested to create a brand new talent, generate a whole SKILL.md file.nn"
"Learn `references/skill-spec.md` for the format specification.n"
"Learn `references/example-skill.md` for a working instance.nn"
"Observe these guidelines:n"
"1. Title have to be kebab-case, max 64 charactersn"
"2. Description have to be underneath 1024 charactersn"
"3. Directions must be clear, step-by-stepn"
"4. Reference information in references/ for detailed area knowledgen"
"5. Maintain SKILL.md underneath 500 strains, put particulars in references/n"
"6. Output the whole file content material the person can save directlyn"
),
assets=fashions.Assets(
references={
"skill-spec.md": "# Agent Abilities Specification (agentskills.io)...",
"example-skill.md": "# Instance: Code Overview Ability...",
}
),
)Python
The assets area is the place the fashions.Assets class turns into important. The references embed the agentskills.io spec as skill-spec.md and a working code-review talent as example-skill.md. When the agent calls load_skill_resource("skill-creator", "references/skill-spec.md"), it will get the total specification that governs how legitimate abilities are structured.
Finest Apply for Generated Abilities: Whereas auto-generating abilities is a robust workflow, we suggest maintaining a human-in-the-loop to evaluation the ultimate SKILL.md. As a normal follow for any talent you construct, it is best to check its effectiveness. You may simply do that by constructing sturdy evaluations with ADK to make sure your talent works precisely as meant earlier than deployment.
The Ability manufacturing unit in motion
Ask the agent: “I would like a brand new talent for reviewing Python code for safety vulnerabilities.”
The agent masses the talent creator, reads the spec and instance by way of load_skill_resource, and generates a whole Python safety evaluation talent with legitimate kebab-case naming, structured directions protecting enter validation, authentication, and cryptography, and a severity-based reporting format.
The generated talent follows the identical agentskills.io spec, so it really works not simply in ADK however in any suitable agent: Gemini CLI, Claude Code, Cursor, and 40+ different merchandise which have adopted the format.
Wiring all of it collectively
With all 4 abilities outlined, packaging them right into a SkillToolset and handing it to the agent takes just a few strains:
# ADK Pseudocode: Assemble the Ability Manufacturing unit
skill_toolset = SkillToolset(
abilities=[seo_skill, blog_writer_skill, content_researcher_skill, skill_creator]
)
root_agent = Agent(
mannequin="gemini-2.5-flash",
title="blog_skills_agent",
description="A blog-writing agent powered by reusable abilities.",
instruction=(
"You're a blog-writing assistant with specialised abilities.n"
"Load related abilities to get detailed directions.n"
"Use load_skill_resource to entry reference supplies.n"
"Observe every talent's step-by-step directions.n"
"All the time clarify which talent you are utilizing and why."
),
instruments=[skill_toolset],
)Python
The primary three abilities within the checklist deal with website positioning, writing, and analysis. The fourth, skill_creator, is the manufacturing unit. Ask this agent “Create a talent for writing technical weblog introductions” and it generates a brand new SKILL.md on the spot:
# Generated by skill-creator
---
title: blog-intro-writer
description: Writes compelling technical weblog introductions. Hooks the reader
with an issue assertion, establishes relevance, and previews what they may be taught.
---
When writing a weblog introduction, observe this construction:
1. Open with a selected downside the reader acknowledges
2. State why it issues now (new launch, scaling ache, frequent mistake)
3. Preview what the put up covers in a single sentence
4. Maintain it underneath 100 phrasesPlain textual content
The agent used the seo-checklist and blog-writer abilities for present duties. When it wanted a functionality it did not have, it wrote one. That new talent follows the identical agentskills.io spec, so it can save you it to abilities/blog-intro-writer/SKILL.md and cargo it with load_skill_from_dir in your subsequent session.
SkillToolset auto-generates three instruments that map on to progressive disclosure: list_skills (L1, injected mechanically), load_skill (L2, on demand), and load_skill_resource (L3, on demand).
A number of professional suggestions earlier than you begin
- Descriptions are your API docs. The
descriptionarea is what the LLM sees at L1 to resolve whether or not to load a talent. “website positioning optimization guidelines for weblog posts” tells the agent precisely when to activate. “A useful talent” doesn’t. - Begin with inline, graduate to information. Do not over-engineer. In case your talent matches in 10 strains of directions, hold it inline. Transfer to a file-based talent if you want reference paperwork or need to reuse throughout brokers.
- Overview generated abilities like dependencies. A meta talent’s output turns into your agent’s habits. Deal with generated SKILL.md information like a code evaluation. Learn earlier than you deploy.
Get began
Able to construct your individual talent manufacturing unit? Take a look at the ADK Abilities documentation to grasp SkillToolset and progressive disclosure, and clone the GitHub repository to run all 4 patterns with ADK.
