OpenAI, Microsoft, Amazon Launch Agent Plugins Open Standard for AI Agents

AI titans to tidy agent frontier with plugin prescription

The AI giants have joined forces to ask the world's developers to all please write their agentic skills and tools into the same format. In return, coders will be able to move these superpowers easily from one platform to another (such as when they get laid off). It's designed to be write once, run everywhere. Vercel posted the initial draft of the Agent Plugins spec on Thursday, with input from Amazon, Cursor, Microsoft, and OpenAI, which all pledged fidelity (and engineers) to the project. It was quickly embraced by the Linux Foundation's Agentic AI Foundation (AAIF), though it will operate as an independent entity. Agent Plugins 1.0 packages an AI agent's skills and tools in a single directory structure. It builds on the AAIF-stewarded MCP protocol and the open Agent Skills standard originally created by Anthropic in 2025. Agent Skills holds the instructions for how the agent should perform a specific task. MCP provides the connectivity to outside databases, APIs, shell scripts, and other external resources. Together, the trio makes AI capabilities modular so that they are, in theory, write-once-run-anywhere. It is still up to the agent clients, or platforms, to provide a user interface, establish security boundaries and create marketplaces where the plugins can be shared. Thus far, VS Code, Cursor, GitHub Copilot, ChatGPT, Codex, and Kiro all support the standard. File-system-as-configuration Agent Plugins follows the Next.js practice of using the host computer's directory format as the structure for defining components. The spec prescribes creating a top-level directory for each plug-in, with a small manifest and schema. The manifest provides the name, version and schema of the plugin in JSON format. Skills are filed in the skills sub-directory, and the MCP server configuration is stored as an mcp.json file. Those are the essential elements, though the plugin authors can also use the namespace directory to store additional extensions. This format "keeps the shared format predictable without requiring it to absorb every client-specific experiment happening across agent products," noted the AAIF in a blog post. Bundling the skills with the MCP configuration makes the package portable, allowing it to be copied and used across any supporting agent client. The narrow way Agent developers around the globe are adding all manner of experimental hooks, rules and extensions into their skills. Nonetheless, the keepers of the spec deliberately kept the scope "narrow" for this 1.0 release, in AAIF's words. The best ones may be considered for future versions of the spec, though the team is not making any promises. Until then, developers can add all these extensions to the namespace and hope for the best, portability-wise. Going forward, Agent Plugins will be managed under an open governance model, with an independent technical oversight committee calling the shots, considering input from the public. Currently, engineers from Amazon, Cursor, Microsoft, OpenAI, and Vercel are on the core development team. The spec is licensed under the Creative Commons Attribution 4.0 International License (CC-BY-4.0). There are other efforts underway to tame the wild frontier of agent development. Google folded its own Agent2Agent (A2A) agentic communications protocol effort into AAIF. Google is also building out a specification for finding tools on the web, called Agentic Resource Discovery. AAIF has a similar "complementary" project to Agent Plugins, Skills Over MCP, which shares skills by bundling them into the MCP server itself. Essentially, this approach is akin to shipping "the manual with the product," wrote AAIF Vice President Angie Jones. Should MCPs be festooned with skills? Or should each set of skills come with an attached MCP? Let the best approach win! ®

OpenAI and rivals agree on a standard for AI agents

OpenAI, Amazon, Microsoft, Cursor, and Vercel have agreed on a shared format for agent add-ons. Build a plugin once, and it runs across ChatGPT, Copilot, Cursor, and more. The AI race spent two years being about models. This week it moved to the plumbing. On the eve of GPT-5's first birthday, OpenAI and four rivals published Agent Plugins, an open standard that lets a single agent extension work across competing products. The pitch is "build once, run anywhere". Today, every agent tool expects a different folder layout and setup. Agent Plugins replaces that with one package format. It bundles two things developers already use. The first is Model Context Protocol servers, which connect an agent to live tools and data. The second is Agent Skills, reusable sets of instructions. A plugin is just a folder with a small plugin.json file at its root. Who is behind it Despite the OpenAI billing, this is not an OpenAI product. Vercel initiated the proposal. Representatives from Amazon, Cursor's maker Anysphere, GitHub, Microsoft, OpenAI, and Vercel then shaped the 1.0 specification. The steering committee has five members: Amazon, Cursor, Microsoft, OpenAI, and Vercel. The project is openly licensed, and its backers say no single company's roadmap sets its direction. OpenAI still framed the launch as its own milestone. GPT-5 turns one on 7 August, and the company is marking the week by looking beyond individual models, per 9to5Mac. Its ChatGPT and Codex apps support the format at launch, alongside Cursor, GitHub Copilot, Kiro, and VS Code. The move goes further than OpenAI's own Codex plugins, which work only inside its tools. Deliberately small The standard is narrow on purpose. It defines how a plugin is packaged and found, and little else. Marketplaces, installation, permissions, sandboxing, and trust all stay with each client. That keeps the format easy to adopt. It also leaves the hardest problems unsolved. Deciding whether a plugin is safe to run is still every client's own job, a live worry after fake Agent Skills slipped past security scanners earlier this year. Not everyone is convinced. Dax Raad, who builds the SST developer-tools framework, said he was "very much against" it, calling it "a thin standard" whose useful parts will end up in client-specific extensions anyway. Others cheered. "We neeeeded this," wrote developer advocate Angie Jones, who had wanted one way to carry her skills between the tools she uses. The bigger question is what standardising the plumbing does to competition. A shared format could let a small developer reach every major agent at once. That is the open-ecosystem case, and it is a real one. It could also cement the handful of clients that already have the users, because a standard rewards whoever people already run. For now the plumbing is agreed. The fight over the parts it leaves out, the marketplaces and the trust, has barely started.

OpenAI Launches Vendor-Neutral Agent Plugins Open Standard

OpenAI introduces Agent Plugins, a vendor-neutral open standard aimed at simplifying the creation and deployment of software agent extensions. By addressing challenges such as platform-specific compatibility, this framework supports more efficient workflows and greater interoperability across systems. The structure is built around two key components: Agent Skills, which are modular workflows for defined tasks and MCP Servers, which assist connections between agents, APIs and external data sources. This design ensures that plugins remain both functional and adaptable as technology evolves. Discover how the standardized folder structure, including a 'plugin.json' manifest, supports consistent integration across platforms. Learn how developers can use the modular design to incorporate Agent Skills, MCP Servers, or both, depending on project needs. This explainer also examines how Agent Plugins balance standardization with flexibility, allowing developers to create scalable solutions without sacrificing customization. The Importance of Standardization Standardization is a critical factor in the success of Agent Plugins, as it resolves one of the most persistent challenges faced by developers: platform-specific compatibility issues. Without a unified framework, developers often spend significant time and resources adapting plugins to work with different agent platforms. Agent Plugins eliminates this inefficiency by introducing a consistent structure that ensures extensions function reliably across multiple environments. This not only accelerates the development process but also enhances the overall reliability and usability of plugins. By adopting this standard, developers can focus on innovation rather than troubleshooting compatibility problems. Core Components of Agent Plugins Agent Plugins is built around two key components that enhance its adaptability and functionality, making it a versatile tool for developers: * Agent Skills: These are modular, reusable workflows or instructions that enable software agents to perform specific tasks. By packaging these skills into plugins, developers can create scalable and portable solutions that simplify the development process. Agent skills are designed to be flexible, allowing developers to address a wide range of use cases efficiently. * MCP Servers: Middleware Communication Protocol (MCP) servers act as connectors, linking agents to external tools, APIs and data sources. By integrating MCP servers into plugins, developers can expand the capabilities of their agents without compromising portability or compatibility. This modular approach ensures that plugins remain adaptable to evolving technological requirements. Here are more detailed guides and articles that you may find helpful on AI Agents. Streamlined Plugin Structure The structure of Agent Plugins is intentionally designed to prioritize simplicity and efficiency. Each plugin is organized as a folder containing a 'plugin.json' manifest file at its root. This manifest serves as the blueprint for the plugin, detailing its metadata, capabilities and dependencies. The standardized format ensures that plugins are easily discoverable and interoperable across various platforms. This eliminates the need for custom configurations, reducing development time and allowing seamless integration into diverse environments. By adhering to this structure, developers can create robust and portable plugins that meet the needs of modern software agents. Developer-Centric Benefits Agent Plugins offers a range of advantages tailored specifically to the needs of developers, making it an invaluable tool for building and deploying agent extensions: * Efficiency in Development: The unified format eliminates the need for platform-specific adjustments, allowing developers to focus on creating innovative solutions rather than resolving compatibility issues. * Enhanced Portability: The open standard ensures that plugins can be easily shared and reused across different systems, reducing redundant work and fostering collaboration. * Seamless Interoperability: Designed with compatibility in mind, Agent Plugins facilitates smooth integration between agents and third-party tools, enhancing the overall functionality of software ecosystems. * Scalability for Growth: The flexible architecture supports the addition of new features, allowing developers to adapt their plugins to meet evolving project requirements and technological advancements. Flexible Implementation Options Agent Plugins is designed to accommodate a wide variety of use cases, offering developers the flexibility to include agent skills, MCP servers, or both within their plugins. This modular approach allows developers to tailor their solutions to the specific needs of their projects. However, it is important to note that the standard focuses exclusively on packaging and discovery. Elements such as marketplaces, permissions and runtime environments are left open for customization, giving developers the freedom to adapt these aspects to their unique requirements. This balance between standardization and flexibility ensures that Agent Plugins remains a versatile and developer-friendly solution. A Collaborative and Open Ecosystem As an open standard, Agent Plugins is freely accessible to all developers, regardless of their preferred platforms or ecosystems. Its vendor-neutral approach encourages collaboration and innovation, breaking down barriers between competing technologies. By adopting this standard, developers contribute to a more unified and efficient ecosystem for software agents, benefiting not only individual projects but also the broader tech community. This collaborative framework fosters the exchange of ideas and resources, driving progress in the field of software agents. Shaping the Future of Software Agents Agent Plugins represents a fantastic approach to simplifying the development and integration of software agent capabilities. By providing a standardized, open format, it reduces complexity, enhances portability and promotes interoperability across platforms. Whether you are building modular agent skills, integrating MCP servers, or using both, Agent Plugins offers a flexible and practical solution that enables developers to innovate with confidence. To explore more about Agent Plugins and access additional resources, visit agentplugins.org. Media Credit: OpenAI Disclosure: Some of our articles include affiliate links. If you buy something through one of these links, Geeky Gadgets may earn an affiliate commission. Learn about our Disclosure Policy.