Introducing Agent Plugins: A Vendor-Neutral Standard for AI Agent Extensions

The new specification provides a common format for packaging Agent Skills and MCP servers across major AI clients.

Vercel announced today that Agent Plugins 1.0.0 is publicly available, introducing a new open, vendor-neutral standard for plugins that extend AI agents. The specification provides a common format for packaging reusable instructions and resources, allowing developers to build extensions that work seamlessly across different AI client environments. By introducing agent plugins, the collaborating companies aim to eliminate the need for extension authors to repackage the same components for every individual client.

Prior to this specification, extension authors frequently adapted the same underlying component to several different client formats. Even though the core Agent Skill or Model Context Protocol (MCP) server was identical, clients often expected different top-level metadata, discovery paths, or configuration files. Agent Plugins gives those shared components one predictable, structured home, establishing a portable contract between the authors who build extensions and the clients that load them.

The initiative was initiated by Vercel and refined collaboratively by representatives from Amazon Web Services (AWS), Anysphere, GitHub, Microsoft, OpenAI, and Vercel. According to the official announcement, the project is openly licensed, ensuring that no single company's product roadmap sets the format's direction. The initial Technical Steering Committee includes Core Maintainers from AWS, Cursor, Microsoft, OpenAI, and Vercel.

One Package for the Portable Parts

At the core of the Agent Plugins specification is a minimal JSON manifest (plugin.json) that identifies the specification version and names the plugin. These two fields represent the minimum requirement for the manifest, while the rest of the contract is represented in the file structure of the directory itself. The format is intentionally small and easy to implement, leaving installation, distribution, policy, user experience, and client-specific capabilities to each client.

Every compatible client checks for plugin.json at the plugin root. From there, clients that support Skills discover them under the skills/ directory, while clients that support MCP servers read their configuration from mcp.json. A client can support either component type or both. After the client validates the manifest, components are validated independently, ensuring that one invalid component does not disable unrelated ones.

Technical Specifications and Component Structure

Version 1.0.0 focuses the portable contract on two primary component types: Agent Skills and MCP servers. Both already have their own specifications and meaningful adoption, and Agent Plugins does not attempt to redefine them. Instead, it provides a shared definition of how clients find these components together in a distributable plugin.

Component Type Location Description
plugin.json Plugin Root Minimal manifest identifying specification version and plugin name
Agent Skills skills/ Reusable instructions and resources for AI agents
MCP Servers mcp.json Configuration to connect agents to tools and services

Other components, such as commands, hooks, and agents, remain with the clients. The Technical Steering Committee may consider additional component types in future versions as semantics converge and a demonstrated portability need emerges. Keeping the boundary small makes the format easier to implement and gives the ecosystem room to converge before adding more portable surface area.

Small on Purpose: Balancing Standardization and Flexibility

Clients need the freedom to innovate while a shared format evolves. To accommodate this, Agent Plugins includes a namespaced extension mechanism for client-specific data and files. Extensions remain outside the portable contract—each client defines its own namespace, and other clients ignore it. This architecture prevents client-specific behavior from leaking into the common format or blocking the adoption of shared components.

For plugin authors, introducing agent plugins means fewer client-specific conventions for the same component. A reusable component should not need to be repackaged for every client, so the format specifies only what a client needs to discover and load what is inside. For client implementers, the specification defines a small, deterministic contract for discovery, validation, and loading. Jeff Dean and Other Top AI Researchers Depart Google to Launch Scientific Discovery Startup

An Open, Multi-Vendor Project

The governance model of Agent Plugins emphasizes open contribution and multi-vendor collaboration. The specification, its JSON Schemas, and guides for plugin authors and client implementers are available at agent-plugins.org. Governance and the contribution process live in the Agent Plugins specification repository on GitHub.

This open approach ensures that the format's direction is set by community consensus rather than individual corporate roadmaps. The Technical Steering Committee, composed of Core Maintainers from leading AI and cloud infrastructure companies, will oversee future iterations and consider additional component types as the ecosystem matures. Nvidia doesn’t mess around: Open Secure AI Alliance already proposing agent defenses

Build with Agent Plugins 1.0.0

At launch, Agent Plugins are supported across several major AI development environments:

  • ChatGPT and Codex (OpenAI)
  • Cursor (Anysphere)
  • GitHub Copilot (Microsoft/GitHub)
  • Kiro
  • VS Code (Microsoft)

Plugin authors can package components once, and their plugin will automatically carry between supporting clients. If you author agent extensions, you can use the specification to package Skills and MCP servers behind one portable manifest. If you build an agent client, the specification's conformance checklist defines the minimum requirements for discovering and loading Agent Plugins.

The introduction of this standard marks a significant step toward interoperability in the AI agent ecosystem. By providing a shared, portable format, Agent Plugins reduces development friction and allows creators to focus on building capable extensions rather than managing client-specific packaging. The contract between authors and clients is now defined and open for both sides to shape.

For further details, refer to the official announcement on the Vercel blog and the Agent Plugins 1.0.0 changelog.

Key Takeaways

  • Agent Plugins 1.0.0 is now publicly available as an open, vendor-neutral standard for packaging AI agent extensions.
  • The specification utilizes a minimal plugin.json manifest and fixed directory locations to unify Agent Skills and MCP servers.
  • At launch, the standard is supported by ChatGPT and Codex, Cursor, GitHub Copilot, Kiro, and VS Code.
  • The project is governed by a multi-vendor Technical Steering Committee including AWS, Microsoft, OpenAI, and Vercel.