Plugins

Plugins are modular software extensions that connect large language models and other AI systems to external tools, services, data sources, and user interfaces, letting a model trained on a static corpus reach into the live world: querying search engines, placing orders, controlling spreadsheets, reading code, and acting on a user's behalf. The term is most strongly associated with ChatGPT Plugins, the beta marketplace OpenAI launched on March 23, 2023 and deprecated on April 9, 2024 ^[1][2]. Although that first-generation format is now historical, the broader plugin paradigm is very much alive: it has shifted from bespoke per-vendor connectors toward Custom GPTs, native tool use APIs, editor and browser extensions, and the open Model Context Protocol (MCP) that any AI client can use to reach any tool ^[5].

The history of AI plugins is short but eventful. OpenAI opened a marketplace of third-party connectors that let GPT-4 browse the web, run code, and call services such as Expedia, Instacart, KAYAK, OpenTable, Wolfram and Zapier. Just over a year later OpenAI wound the system down in favor of Custom GPTs and the GPT Store, which by 2024 had passed 3 million user-created GPTs ^[4]. In parallel, Anthropic released the open Model Context Protocol on November 25, 2024, standardizing how any AI client connects to any tool through a common transport ^[5]. OpenAI itself adopted MCP across its own products on March 26, 2025 ^[6], cementing the protocol as the successor to the proprietary plugin marketplace. Today the word "plugin" remains in widespread use, but the underlying technology has moved to open protocols, native tool-use APIs, and editor extensions for Cursor, Visual Studio Code and similar tools.

What is an AI plugin?

A plugin is a piece of software that adds a specific capability to a host program without requiring changes to that program's core code. In traditional software, examples include WordPress plugins, Photoshop filters, and browser extensions. In AI, plugins serve the same architectural purpose but with one important twist: the host program is a language model that decides, based on the user's natural language request, which plugin to call and with what arguments. The model essentially acts as a router and reasoner, while the plugin handles the deterministic part of the work such as fetching a flight price, looking up a stock quote, or executing a database query.

This arrangement is sometimes called the "reasoning core, action periphery" pattern. The model contributes language understanding and planning. The plugin contributes facts, side effects, and access to systems the model cannot reach on its own. The combination makes generative AI systems substantially more useful than a model alone, because the model is no longer limited to the contents of its training data.

AI plugins typically fall into three broad families:

Scroll sideways for more →

A fourth, increasingly important category is the open protocol layer represented by MCP. MCP servers are not plugins for any single AI host; they are independent processes that any compliant client can connect to. This architectural choice, discussed below, is the main reason the original ChatGPT Plugins format faded from mainstream use.

What were ChatGPT Plugins?

See also: ChatGPT Plugins, List of ChatGPT Plugins

ChatGPT Plugins were the first widely deployed AI plugin marketplace and remain the most historically significant example of the category. OpenAI announced the system in a blog post titled "ChatGPT plugins" on March 23, 2023, framing them as "the eyes and ears" of the model and a step toward a more capable assistant ^[1]. The launch included a small set of first-party plugins (a web browser and a code interpreter, the latter of which later became Advanced Data Analysis) and an alpha rollout to selected developers and ChatGPT Plus subscribers.

Within weeks the catalog grew to include partner integrations from Expedia, FiscalNote, Instacart, KAYAK, Klarna, Milo, OpenTable, Shopify, Slack, Speak, Wolfram and Zapier ^[1]. By mid-2023, hundreds of plugins were live, and ChatGPT Plus users could enable up to three at a time per conversation. The launch was widely covered and was treated by many commentators as a turning point similar to the introduction of the App Store on the iPhone.

When were ChatGPT Plugins deprecated?

ChatGPT Plugins were retired in two stages in 2024. On March 19, 2024, OpenAI disabled the plugin store and stopped users from creating new conversations with plugins; on April 9, 2024, it ended all remaining plugin conversations, so the system was fully shut down ^[2]. In its help-center notice, OpenAI said it was "winding down the plugins beta" because "GPTs are the best way to customize ChatGPT, with more features and strong adoption from users and developers" ^[2]. Key dates in the lifecycle are summarized below.

Scroll sideways for more →

The roughly twelve-month run of ChatGPT Plugins makes them one of the shortest-lived major product categories in OpenAI's history. The deprecation notice instructed users and developers to migrate to GPTs, which use the same general execution model (Actions backed by an OpenAPI specification) but bundle them into a configurable assistant rather than a flat plugin list ^[2][3].

How did the ChatGPT Plugins architecture work?

The ChatGPT Plugins architecture had two core artifacts: a manifest and an OpenAPI specification. Together they described to ChatGPT how to talk to a third-party service.

1. Plugin manifest (ai-plugin.json) A small JSON file served at /.well-known/ai-plugin.json on the plugin's domain. The manifest contained metadata such as the human-readable name, description, contact email, logo URL, legal info URL, and pointers to the API specification and authentication scheme.
2. OpenAPI specification A standard OpenAPI (formerly Swagger) document describing the available endpoints, request parameters, response schemas, and any required authentication. ChatGPT used this spec to construct calls in real time during a conversation.
3. Authentication The system supported four authentication modes: no auth (for public services), service-level auth (a fixed API key shared by all users), user-level auth (a per-user token entered in the ChatGPT UI) and OAuth (full OAuth 2.0 flow for personal accounts).
4. Execution loop When the user issued a request, ChatGPT decided which enabled plugin to call, generated a JSON request matching the OpenAPI schema, sent it to the plugin's server, parsed the response, and incorporated the result into its answer.

This pattern was simple enough that thousands of developers shipped plugins in the first months. It was also flexible: any web service that already had an OpenAPI spec could be turned into a plugin by adding a manifest file. The cost of that simplicity, however, was that each plugin had to be installed by the user and selected manually, and the model often struggled to choose between many similar plugins. These usability frictions were among the reasons OpenAI eventually replaced plugins with Custom GPTs ^[2].

Which ChatGPT Plugins were most notable?

Although the marketplace contained hundreds of entries, a smaller set of plugins received most of the attention from press and users. The table below highlights a representative sample.

Scroll sideways for more →

Many of these vendors later returned to the AI ecosystem as Custom GPTs, MCP servers, or direct API consumers, but the original plugin versions stopped functioning after April 9, 2024 ^[2].

How did Custom GPTs replace plugins?

On November 6, 2023, at its first DevDay conference, OpenAI announced GPTs ^[3]. These are user-configurable versions of ChatGPT, each with a name, an avatar, a system prompt, optional knowledge files, and optional Actions that connect to external services. The Actions feature reused the OpenAPI-spec mechanism from plugins, but moved the integration inside a packaged assistant rather than exposing a free-form plugin list.

The GPT Store launched on January 10, 2024 and gave Custom GPTs the discoverability that the older plugin store had lacked ^[4]. OpenAI reported that users had created more than 3 million custom GPTs since the feature launched, spanning specialized assistants for coding, writing, design, education and shopping ^[4]. From a developer's perspective, building a Custom GPT with Actions is similar to writing a ChatGPT Plugin: the same OpenAPI patterns apply. From a user's perspective, however, the experience is very different, because each GPT has a curated identity rather than being a generic plugin slot.

Key differences between the old Plugins system and the Custom GPT system are summarized below.

Scroll sideways for more →

For most practical purposes Custom GPTs occupy the niche that plugins once held. A developer who would have built a ChatGPT Plugin in 2023 would, in 2025, build either a Custom GPT, an MCP server, or a direct integration through OpenAI's Assistants API.

How does plugin architecture work in detail?

Most AI plugin systems share three architectural ingredients regardless of vendor:

1. A schema describing the tool. Most commonly an OpenAPI document or a JSON Schema describing each function, its parameters, and its outputs.
2. A transport. For ChatGPT Plugins this was HTTPS. For MCP it is typically stdio, HTTP/SSE, or WebSockets. For browser extensions it is the browser's messaging API.
3. A planner inside the model. The model reads the schemas, infers which tool to call, fills in arguments, sends them through the transport, and integrates the response. This step is called tool use or function calling.

The schema is presented to the model through a dedicated tools parameter or via the system prompt. The model emits a structured tool call when it decides one is needed; the host application intercepts it, executes it, and returns the result.

A typical request flow

1. User asks: "Book me a flight to Tokyo on June 1."
2. Model reads the available tool schemas and selects, for example, a search_flights function.
3. Model emits a structured call: search_flights(destination="Tokyo", date="2026-06-01").
4. Host executes the call against the airline's API.
5. API returns flight options as JSON.
6. Model reads the JSON and replies in natural language.

This pattern is functionally identical across ChatGPT Plugins, Custom GPT Actions, Anthropic tool use, Gemini function calling, and MCP. The differences are in transport, packaging, distribution and discovery.

What are browser and IDE plugins?

Two large families of AI plugins live outside the AI vendor's own product: browser extensions and editor extensions.

Browser plugins

Browser plugins inject AI functionality into web pages or add a sidebar that calls an AI service. They are distributed through the Chrome Web Store, Firefox Add-ons, and equivalent stores for Edge and Safari. Notable examples include:

Scroll sideways for more →

As major browsers added native AI features, especially Microsoft embedding Copilot into Edge and Google integrating Gemini into Chrome, the third-party browser plugin ecosystem became less central, though many remain widely used.

IDE and editor plugins

The other large non-vendor plugin category lives inside code editors. AI assistants for programmers entered the mainstream with GitHub Copilot, released as a Visual Studio Code extension on June 29, 2021 and made generally available on June 21, 2022 ^[10][13]. Copilot's success demonstrated that AI features inside an editor were a fundamentally different product from a chat interface, and triggered a wave of follow-up extensions and dedicated AI editors.

The table below lists notable editor-side plugins and AI-native editors.

Scroll sideways for more →

Most modern editor plugins now build on the same tool-use machinery as MCP and function calling. Cursor, for example, lets users add MCP servers as first-class extensions, so a single MCP integration can serve both the editor and any other MCP-compatible client ^[12].

What is the Model Context Protocol?

From 2024 onward the most important development in plugin architecture was the rise of the Model Context Protocol (MCP). Anthropic introduced MCP as an open standard on November 25, 2024, describing it as "a new standard for connecting AI assistants to the systems where data lives," and shipped reference implementations alongside it ^[5]. The initial release (spec version 2024-11-05) came with Python and TypeScript SDKs and pre-built servers for GitHub, Slack, Google Drive, Postgres, and other services ^[5][6]. Within months, MCP servers had been published for Brave Search, filesystem access, and dozens of other tools.

MCP differs from earlier plugin systems in three important ways:

Scroll sideways for more →

By 2025, MCP servers had become the de facto way to extend Claude, Claude Desktop, Cursor, Cline, and many open-source clients. In a striking endorsement from a direct competitor, OpenAI added MCP support across its own products on March 26, 2025; OpenAI CEO Sam Altman wrote, "People love MCP and we are excited to add support across our products" ^[6]. As of mid-2026 the public MCP registry lists hundreds of community-maintained servers, and large platform vendors such as Google, Microsoft, and Cloudflare ship official MCP integrations.

Anthropic also offers Claude Skills, a packaging format for reusable instructions and assets that load on demand. Skills sit alongside MCP rather than replacing it: MCP exposes external tools, while Skills bundle prompts, scripts, and resources that travel with Claude.

How do API tool use and function calling relate to plugins?

A fourth way to think about AI plugins is at the API level. OpenAI, Anthropic, Google, and xAI all offer first-class tool-use parameters, letting developers attach functions to any model call without going through the vendor's product UI.

On June 13, 2023, OpenAI added a functions parameter to the Chat Completions API ^[8]. It was later renamed to tools and expanded to include parallel calls. Anthropic launched its own tools parameter for the Claude API, reaching general availability on May 30, 2024 with a JSON-Schema-based contract ^[7], and Google and xAI followed for Gemini and Grok.

The table below compares the three most widely used tool-use APIs as of 2026.

Scroll sideways for more →

For many production systems, raw API tool use has effectively replaced packaged plugin marketplaces. A backend service can attach exactly the tools it needs to a model call, audit every invocation, and run within the developer's own infrastructure rather than depending on the AI vendor's plugin sandbox. This pattern is the dominant approach behind enterprise AI assistants, autonomous agents like Devin, and most modern AI applications shipped in 2025 and 2026.

How do the major plugin formats compare?

The table below summarizes how the major AI plugin formats compare in terms of openness, host coupling, and current status.

Scroll sideways for more →

In practice, building a serious integration in 2026 typically means choosing some combination of MCP, native tool use, and an editor or browser extension. Pure ChatGPT-Plugin-style integrations are no longer a meaningful option.

What lessons did the plugin era teach?

The rapid rise and retirement of ChatGPT Plugins between 2023 and 2024 left several durable lessons for the AI industry.

1. Discovery matters more than authoring. Hundreds of plugins shipped in the first months, but most users never enabled more than two or three. The flat plugin store exposed too many similar entries, and ChatGPT struggled to pick the right one. Custom GPTs solved part of this with named integrations, while MCP sidestepped the problem entirely with per-client installs.
2. Vendor lock-in is a non-starter. Developers built for ChatGPT Plugins while it was the only game in town, but once Anthropic, Google, and open-source clients introduced competing systems, multi-target reuse became essential. MCP succeeded in part because it works across all compliant clients, and OpenAI's own March 2025 adoption of the protocol confirmed the point ^[6].
3. Authentication and trust boundaries are critical. OAuth flows and per-user credentials were the most common stumbling block for plugin developers. Subsequent designs require explicit confirmation for destructive actions to defend against prompt injection.
4. The model is part of the platform. A plugin's success depends on the host model's ability to choose it correctly. Stronger models such as GPT-4 and Claude 3.5 Sonnet made tool use far more reliable for production work.
5. Open protocols outlast proprietary marketplaces. Within roughly eighteen months, the proprietary ChatGPT Plugin format had been replaced by Custom GPTs internally and MCP externally.

See also

• ChatGPT Plugins
• Custom GPTs
• GPT Store
• Model Context Protocol
• Function calling
• Tool use
• Cursor
• GitHub Copilot
• Claude Skills
• OpenAPI Specification

ChatGPT Plugins (legacy entries)

See also: List of ChatGPT Plugins

The table below preserves the original entries from the previous version of this article. All listed plugins ceased operation on April 9, 2024 along with the rest of the ChatGPT Plugins system.

Scroll sideways for more →

References

1. OpenAI. "ChatGPT plugins." OpenAI Blog, March 23, 2023. https://openai.com/index/chatgpt-plugins/ ↩
2. OpenAI. "Winding down the ChatGPT plugins beta." OpenAI Help Center (deprecation notice), 2024. https://help.openai.com/en/articles/8988022-winding-down-the-chatgpt-plugins-beta ↩
3. OpenAI. "Introducing GPTs." OpenAI Blog, November 6, 2023. https://openai.com/index/introducing-gpts/ ↩
4. OpenAI. "Introducing the GPT Store." OpenAI Blog, January 10, 2024. https://openai.com/index/introducing-the-gpt-store/ ↩
5. Anthropic. "Introducing the Model Context Protocol." Anthropic News, November 25, 2024. https://www.anthropic.com/news/model-context-protocol ↩
6. TechCrunch. "OpenAI adopts rival Anthropic's standard for connecting AI models to data." March 26, 2025. https://techcrunch.com/2025/03/26/openai-adopts-rival-anthropics-standard-for-connecting-ai-models-to-data/ ↩
7. Anthropic. "Tool use with Claude." Anthropic Documentation. https://docs.anthropic.com/en/docs/build-with-claude/tool-use ↩
8. OpenAI. "Function calling and other API updates." OpenAI Blog, June 13, 2023. https://openai.com/index/function-calling-and-other-api-updates/ ↩
9. Model Context Protocol Project. Official documentation. https://modelcontextprotocol.io/
10. Wikipedia contributors. "GitHub Copilot." Wikipedia, The Free Encyclopedia. https://en.wikipedia.org/wiki/GitHub_Copilot ↩
11. Wikipedia contributors. "OpenAPI Specification." Wikipedia, The Free Encyclopedia. https://en.wikipedia.org/wiki/OpenAPI_Specification
12. Cursor. "Cursor Documentation: Extensions and MCP servers." https://docs.cursor.com/ ↩
13. GitHub. "GitHub Copilot: General availability." GitHub Blog, June 21, 2022. https://github.blog/news-insights/product-news/github-copilot-is-generally-available-to-all-developers/ ↩