Agent Plugins standardize how AI coding tools share components

When you build skills for AI coding agents, you face a packaging problem. The skill itself works fine. The server connecting it to tools works fine. But every platform wants these components wrapped differently — different folder structures, different config formats, different metadata requirements. Agent Plugins solves this by defining one standard way to package these pieces together.

What Agent Plugins actually changes

Agent Plugins is a specification, not a product. It defines how to bundle:

• Agent Skills (reusable instructions and resources for AI agents)
• MCP servers (connections to tools and services)
• Client-specific extensions (platform hooks and customizations)

The key innovation is constraint. A plugin must use this exact structure:

reports-plugin/  
├── plugin.json  
├── skills/  
│   └── summarize/  
│       ├── SKILL.md  
│       ├── scripts/  
│       └── references/  
├── mcp.json  
└── com.example.client/  

Why this matters for learners

Three concrete improvements when you adopt this:

1. No more fork-and-drift
   
   Previously, shipping to multiple platforms meant maintaining separate copies of essentially the same components. Now you maintain one package that works everywhere.

2. Independent failures
   If your MCP server fails to start, the agent still loads your skills. The spec enforces loose coupling between components.

3. No hidden discovery rules
   Unlike some proprietary formats, there’s no magic path resolution or config precedence to learn. Everything lives at fixed locations.

When not to use a plugin

The spec authors explicitly warn against over-engineering:

• Use a standalone Skill when you only need instructions (e.g., a code review checklist)
• Use standalone mcp.json when connecting one tool to one agent
• Only reach for a Plugin when bundling multiple interdependent components

How major platforms are adopting it

Google’s first supported products:

What’s deliberately missing

The spec omits several things you might expect:

• No installation mechanism
• No permission model
• No sandboxing rules
• No UI/UX guidelines

This keeps the standard focused and lets each platform handle these concerns differently.

How this fits with other standards

Agent Plugins slots into an emerging stack:

1. Discovery: Agentic Resource Draft (ARD) finds available plugins
2. Description: AI Catalog entries reference plugin.json
3. Packaging: This spec defines the directory structure
4. Execution: MCP and Skills handle runtime behavior

You can adopt each layer independently — for example, using plugins without ARD discovery.

What to do next

1. Try building one
   Create a folder with:

   • plugin.json containing just {"name":"demo"}
   • skills/greet/SKILL.md with hello-world instructions

2. Check existing plugins
   Examine Google’s Data Agent Kit plugins to see real-world examples.

3. Read the spec
   At 12 pages, it’s intentionally brief — the reference implementation is under 300 lines of code.

Packaging standards aren’t glamorous, but they’re what let your skills work anywhere without rewrite. This one’s worth learning because it’s the first with cross-vendor backing.

Want to try all of this hands-on? Start with the free Claude Code from Zero course.