Can Your AI Agent Write New Instructions? Exploring Google ADK’s New Skills Feature

“Your AI Agent can follow instructions. But can it write new instructions?” — Google Developers Blog, April 2026

Developers of AI agents often hit a "context window wall" by stuffing all possible knowledge into the system prompt, burning thousands of tokens before the user even speaks.

Industry’s short‑term fix has been to enlarge the context window—OpenAI, Anthropic, and now Google have done so—but this only works until an agent needs expertise across dozens of domains.

What is Google ADK?

Google ADK (Agent Development Kit) is an open‑source framework for building Gemini‑model‑driven agents. It supports Python, Java, Go, and TypeScript and handles model orchestration, tools, memory, and multi‑agent coordination, acting like a "Rails" for AI agents.

Core ADK components:

Agent : the brain (model, name, instructions, tools)

Session : conversation memory

Runner : execution engine that processes queries and composes responses

Tools : functions, MCP servers, or now skill toolsets that agents can invoke

The breakthrough is the Skills architecture, which solves the problem of giving an agent deep, multi‑domain expertise without bloating every request.

Skills: The Three‑Layer Architecture

Layer 1 – Metadata (≈100 tokens) : a tiny front‑matter card containing the skill’s name and a short description that lets the agent decide whether to activate the skill.

---
name: weather-skill
description: A skill that provides weather information based on reference data.
---

Layer 2 – Instructions (< 5,000 tokens) : the actionable steps loaded on demand via load_skill().

Step 1: Check 'references/weather_info.md' for the current weather.
Step 2: If humidity is requested, run 'scripts/get_humidity.py' with the `location` argument.
Step 3: Provide the update to the user.

Layer 3 – Resources (on‑demand) : reference files, scripts, templates, or vocabularies that are fetched only when a specific instruction needs them. references/weather_info.md – loaded for a temperature query. scripts/get_humidity.py – executed only for a humidity query, saving tokens.

Four Skill Implementation Modes

Inline Skills : define a skill directly in Python code – ideal for rapid prototyping.

File‑Based Skills : store a SKILL.md plus optional reference and script directories – suited for production and reuse.

External/Community Skills : adopt the open agentskills.io standard to share skills across frameworks (Claude Code, Gemini CLI, Cursor, etc.).

Meta‑Skills (Skill Factories) : agents can generate new SKILL.md files at runtime (e.g., a compliance checker), though generated skills should be manually reviewed before deployment.

Step‑by‑Step: Building a Weather Skill

1. Install the kit: pip install google-adk 2. Create the directory layout:

my_agent/
├── agent.py
├── __init__.py
├── .env
└── skills/
    └── weather-skill/
        ├── SKILL.md
        ├── references/
        │   └── weather_info.md
        └── scripts/
            └── get_humidity.py

3. Write SKILL.md (metadata + instructions) as shown above.

4. Add the reference data ( weather_info.md) and the humidity script ( get_humidity.py).

5. Assemble the agent in agent.py:

import pathlib
from google.adk import Agent
from google.adk.skills import load_skill_from_dir
from google.adk.tools.skill_toolset import SkillToolset
from google.adk.code_executors.unsafe_local_code_executor import UnsafeLocalCodeExecutor

weather_skill = load_skill_from_dir(pathlib.Path(__file__).parent / "skills" / "weather-skill")
my_skill_toolset = SkillToolset(skills=[weather_skill], code_executor=UnsafeLocalCodeExecutor())
root_agent = Agent(model="gemini-2.5-flash", name="skill_user_agent", description="An agent that can use specialized skills.", tools=[my_skill_toolset])

6. Run the agent via the ADK Web UI and ask two queries:

"What’s the current weather?" – the agent loads only Layer 1 and Layer 2, then fetches weather_info.md (Layer 3) and returns the temperature.

"What about humidity?" – after Layer 2, the agent runs scripts/get_humidity.py and returns the simulated humidity, never loading the script for the first query.

This demonstrates token‑efficient, on‑demand knowledge loading.

Code Executor Warning

Never use UnsafeLocalCodeExecutor in production; it runs scripts with full system access. Prefer sandboxed executors such as VertexCodeExecutor or AgentEnginesSandboxCodeExecutor.

Google ADK vs. OpenAI Agent SDK

OpenAI’s SDK has a larger ecosystem and better documentation today, but no other mainstream framework offers a native equivalent to ADK’s SkillToolset. The key difference is that ADK focuses on *what the agent needs to know at a given moment* rather than *what it can do*.

Real‑World Use Cases

Enterprise Compliance Agent : activates only the GDPR, SOC 2, HIPAA, or PCI‑DSS skill needed for a query, saving ~75% of tokens per interaction.

Multi‑Domain DevOps Assistant : dynamically loads incident‑response, deployment‑pipeline, or security‑scan skills as required.

Marathon Route Planner (Google Cloud Next 2026): combines GIS, mapping, and race‑director skills, each loaded only for its workflow stage.

Open Standard: agentskills.io

The Skills spec is public on agentskills.io, meaning skills built for ADK run in Claude Code, Cursor, Gemini CLI, and over 40 other tools, creating a network effect similar to an npm ecosystem for agents.

Potential Pitfalls

Skill descriptions must be precise; vague metadata leads to missed or wrong activations.

Never use UnsafeLocalCodeExecutor in production; opt for sandboxed executors.

Review generated SKILL.md files as you would code PRs.

Version‑control Layer 3 resources; stale references cause hallucinations.

Future Outlook

In the next year we expect a Skills marketplace, semantic versioning, composable skill pipelines, and monitoring dashboards that track activation frequency and accuracy.

Adoption of the open standard will drive a massive network effect, turning Skills into the "npm packages" of the agent world.

Conclusion

Google ADK’s Skills feature is more than a performance tweak; it reshapes how we build scalable, knowledge‑intensive agents by modularizing expertise and loading it only when needed. If you’re developing agents in 2026 and haven’t embraced Skills, you’re likely wasting significant token costs.