Agent Plugins 1.0.0 is a new open standard that packages AI agent skills and tool connections into a single, portable format that works across ChatGPT, Cursor, GitHub Copilot, VS Code, and other major coding platforms. Announced on August 6, 2026, the standard was developed collaboratively by OpenAI, AWS, Cursor (Anysphere), GitHub, Microsoft, and Vercel, and it addresses a long-standing friction point in the AI coding ecosystem: developers previously had to repackage the same skill or tool integration separately for each platform they wanted to support.

What Problem Does Agent Plugins Actually Solve?

Before Agent Plugins, if you built a reusable instruction set or tool connection for AI agents, you faced what developers call the "repackaging tax." A skill designed to help an AI assistant summarize code, for example, would need custom metadata, separate setup instructions, and platform-specific configuration for ChatGPT, then again for Cursor, then again for GitHub Copilot. The underlying skill was identical; the packaging was not.

Agent Plugins eliminates this duplication by creating a single container format that bundles two existing standards together: Agent Skills (packaged instruction sets that teach agents how to perform tasks) and MCP server configurations (the connection details that give agents access to live tools and data sources). Once packaged this way, the same plugin installs into any compatible client without modification.

How Is Agent Plugins Different From Existing Standards?

This is a crucial distinction that clarifies what Agent Plugins actually does. The standard is not a replacement for Agent Skills or the Model Context Protocol (MCP); it is a packaging layer that sits on top of both. Think of it like a retail box: Agent Skills are the instruction manual, MCP servers are the cable, and Agent Plugins is the box that ships them together.

• Agent Skills: Define how an AI agent should approach a task through structured instructions and procedures, but say nothing about how to package or distribute them.
• Model Context Protocol (MCP): Standardizes the live connection between an agent and external tools or data sources at runtime, but does not address how a skill plus its MCP configuration gets installed as a single unit.
• Agent Plugins: Wraps both components into a manifest-based format that any compatible client can discover and install without rewriting per-client setup instructions.

The fact that five separate companies co-developed this standard, rather than OpenAI shipping it alone, signals that this was a shared pain point across the entire ecosystem, not a speculative initiative.

What Does an Agent Plugin Actually Look Like?

The format is deliberately minimal. An Agent Plugin is a directory with a required plugin.json manifest file at the root, plus optional subdirectories for skills and MCP server configurations. The minimum manifest requires only two fields: a schema reference and a plugin name.

A typical plugin directory structure includes a skills folder containing Agent Skills in the existing SKILL.md format, an mcp.json file that describes any MCP servers the plugin depends on, and client-specific behavior in reverse-domain namespaces like com.example.client. This structure keeps vendor-specific features from leaking into the portable contract, so other clients simply ignore those namespaces.

Which Platforms Support Agent Plugins at Launch?

Six agent clients shipped support on day one: ChatGPT and Codex (OpenAI), Cursor (Anysphere), GitHub Copilot (GitHub/Microsoft), Kiro, and VS Code (Microsoft). All of them can load both Agent Skills and MCP server configurations from the same plugin package.

This is a genuine multi-vendor coalition. The Technical Steering Committee that governs the standard includes core maintainers from Amazon, Cursor, Microsoft, OpenAI, and Vercel, and the specification has been developed in the open since April 2026. The governance structure explicitly states that no single company's product roadmap sets the format's direction.

What Should Developers Do Right Now?

If you already maintain Agent Skills or MCP servers, the immediate next step is straightforward: restructure your existing assets into the Agent Plugins directory format. This is a low-cost first step that requires no rewriting of the underlying skill or server code, only reorganizing files and adding a plugin.json manifest at the root.

The specification and author guide are available at agent-plugins.org, and the manifest schema is public. However, some details remain undocumented as of the August 6 announcement. The exact versioning scheme, whether an official CLI tool exists to auto-generate plugin manifests, and how plugin discovery and distribution will work across clients are still being finalized.

Steps to Package Your First Agent Plugin

• Create the root directory structure: Set up a folder with plugin.json at the root, a skills/ subdirectory for your Agent Skills, and an mcp.json file if your plugin depends on MCP servers.
• Write the plugin.json manifest: Include the required schema reference and plugin name, plus any optional metadata like version, description, and author information.
• Organize existing skills: Move your SKILL.md files into the skills/ directory, preserving the existing Agent Skills format with name and description frontmatter.
• Configure MCP servers: List any MCP servers your plugin depends on in mcp.json, specifying the transport method (stdio, Streamable HTTP, or legacy HTTP+SSE).
• Test across clients: Validate that your plugin loads correctly in at least one of the six launch clients, using the conformance checklist published in the specification.

What Remains Unknown About Agent Plugins?

This is genuinely new technology, and the announcement is only about 24 hours old as of publication. Several important details have not yet been finalized.

The exact manifest schema, including field names, required versus optional keys, and versioning conventions, was not detailed in the initial announcement. Whether a central plugin registry will exist, similar to the Model Context Protocol registry at registry.modelcontextprotocol.io, is unconfirmed. The security and consent model for plugin installation is also undocumented; it is unclear whether Agent Plugins adds its own permission layer on top of MCP's existing consent model or simply inherits it.

Additionally, how plugin authors will ship updates and how clients will detect and apply those updates is not yet specified. Developers should check agent-plugins.org directly for the current state of the specification before shipping anything that depends on these details.

Why Does This Matter for the Broader AI Coding Ecosystem?

Agent Plugins arrives in the same month as other major standardization efforts, including Cloudflare's WebMCP and broader industry "Agents Week" announcements. This convergence signals that the AI coding tooling ecosystem is consolidating around a small set of shared contracts for the first time.

The standard is deliberately thin, which makes it easy to implement but also means the hard work is just beginning. The real test will be whether plugin registries and marketplaces emerge on top of the format, whether the Technical Steering Committee adds new component types in future versions, and how quickly the six launch clients converge on consistent installation and permission flows.