ChatGPT Plugins and MCP (Model Context Protocol) are both ways to extend AI assistants with external tools and data, but they were built with fundamentally different goals and architectures. ChatGPT Plugins were designed as a consumer marketplace — a curated store of capabilities users could add to ChatGPT. MCP is designed as a developer protocol — a standardised communication layer for integrating AI with any external system. OpenAI deprecated ChatGPT Plugins in April 2024 in favour of GPTs and the Assistants API, which makes this partly a historical comparison, but the architectural differences illuminate why MCP has gained much broader adoption.
What ChatGPT Plugins Were
ChatGPT Plugins (launched March 2023, deprecated April 2024) allowed third-party developers to expose web services to ChatGPT by hosting an OpenAPI specification and a plugin manifest. ChatGPT would discover the plugin via its manifest, read the OpenAPI spec to understand available endpoints, and call those endpoints when relevant to a user’s request. The plugin ecosystem grew to thousands of entries covering shopping, travel, code execution, document analysis, and many other categories. The fundamental limitation was the coupling to ChatGPT: plugins worked only with ChatGPT and required Anthropic, Google, and other providers to build their own incompatible plugin systems, which none did at scale. Each plugin also required a hosted web server — there was no local plugin option — making it unsuitable for personal tools and corporate internal tools where external hosting was not acceptable.
What MCP Is
MCP is an open protocol specification, not a marketplace or a product. Any developer can implement an MCP server without approval from Anthropic or anyone else. Any application that implements the MCP client side of the protocol can connect to any MCP server. The protocol is model-agnostic — MCP servers work with Claude, with Cursor’s AI, with VS Code Copilot, and with any other MCP client, regardless of which underlying model they use. This openness is the central difference from ChatGPT Plugins: plugins were a product feature of one AI service; MCP is infrastructure for the entire AI tooling ecosystem.
Architecture Comparison
ChatGPT Plugins used REST APIs as the communication mechanism — the plugin exposed HTTP endpoints that ChatGPT called directly. This meant the plugin was a web service that needed to be publicly hosted and accessible from OpenAI’s servers. MCP uses a defined message protocol (JSON-RPC over stdio or HTTP) that supports both local and remote deployment. An MCP server can be a command-line tool running on your laptop (no hosting required) or a cloud service — the same protocol works for both. For personal and corporate use cases where data should not leave local systems, MCP’s local deployment option is critical. ChatGPT Plugins had no equivalent — all plugin communication went through OpenAI’s infrastructure.
Figure 1 — ChatGPT Plugins vs MCP: architectural differences
Why Plugins Were Deprecated
OpenAI deprecated ChatGPT Plugins in favour of GPTs (customised ChatGPT instances) and the Assistants API for developers. The reasons were practical: plugins required a separate web server per capability, the marketplace model created quality control challenges, and the ChatGPT-only coupling limited their value. GPTs replaced the consumer use case by allowing ChatGPT to be customised with specific instructions and tools without a separate plugin submission process. The Assistants API replaced the developer use case by providing a more flexible programmatic interface. Neither replacement is a standard protocol — both remain ChatGPT-specific solutions. MCP emerged in the same period as the open-standard answer to the same need: a way for AI models to use external tools without being locked into a single AI provider’s ecosystem.
The OpenAI Response to MCP
OpenAI announced support for MCP in its products in early 2025, integrating it into the ChatGPT desktop application and the Agents SDK. This is a significant acknowledgement: the company that built the original Plugins system, then deprecated it, adopted the open protocol that Anthropic released as the standard. MCP’s design as an open protocol rather than a product feature made this adoption straightforward — OpenAI implementing MCP does not require coordination with Anthropic, just conformance to the specification. The practical result: MCP servers now work with both Claude and ChatGPT, with Cursor and VS Code, and with the growing list of MCP-compatible tools. Plugins could never have achieved this — they were fundamentally a closed, single-vendor feature.
What GPTs and Custom Instructions Replace
For users who built ChatGPT Plugins for personal use — a plugin to access their personal notes, their calendar, their local files — GPTs with custom instructions and the Assistants API are the direct replacements within the OpenAI ecosystem. But GPTs are still ChatGPT-specific and require OpenAI API access. MCP covers the same use case across clients: an MCP server for your notes works with Claude Desktop, Cursor, and any other MCP client. For users not locked into ChatGPT specifically, MCP is the more durable investment — the same server definition continues working regardless of which AI assistant the user prefers today or migrates to tomorrow.
Building for the MCP Ecosystem vs the OpenAI Ecosystem
The practical implication for developers building AI integrations: building an MCP server reaches all MCP clients without additional work; building an OpenAI-specific integration (function calling, Assistants API tools) reaches only OpenAI models. For a business selling access to proprietary data or capabilities, MCP enables a “build once, available everywhere” distribution model that plugins never achieved. The analogy is browser extensions versus web APIs: browser extensions are powerful but limited to one browser; web APIs work for any caller. MCP is the web API model for AI tool integration, and the early ChatGPT Plugins were browser extensions — useful but fundamentally scoped to one platform.
ChatGPT Plugins were an interesting early experiment in AI tool integration that demonstrated both the demand for the capability and the limitations of a closed, marketplace-based approach. MCP represents the evolution of the same idea as an open protocol — one that works across AI clients, supports both local and remote deployment, and requires no approval or gatekeeping. For anyone building AI integrations in 2026, MCP is the protocol to build on; the Plugins era was a useful proof of concept for a capability now delivered much more effectively by an open standard.
Security Model Comparison
ChatGPT Plugins operated in a trust model where OpenAI reviewed plugins before they were listed in the marketplace, providing a minimal quality and safety gate. Users installing a plugin were granting it access to their ChatGPT conversations, and the plugin’s server received the conversation context it needed to respond. MCP has no central gatekeeper — any MCP server can be installed by any user, and the security model relies on the user making informed decisions about which servers to trust. This is both a strength and a weakness. The strength: no approval bottleneck, no single point of failure, no vendor lock-in. The weakness: users need to evaluate server trustworthiness themselves, and malicious servers could theoretically perform prompt injection attacks by returning adversarial content in tool results. The MCP specification includes guidance on client-side security (sandboxing tool results, requiring user confirmation for sensitive operations), and reputable clients implement these protections, but the security model requires more user judgment than a curated marketplace.
The Successor Landscape in 2026
By mid-2026, the tool integration landscape has settled into a relatively clear structure. MCP is the open standard for agent and assistant tool integration across clients. OpenAI’s function calling and Anthropic’s tool use API are the per-application integration mechanisms for application-specific tools that do not need to be shared across clients. OpenAI’s GPT Store and Anthropic’s Claude.ai connector marketplace are curated discovery layers for pre-built integrations, built on top of the underlying protocol mechanisms. The ChatGPT Plugins era — a walled garden marketplace that tried to be both the protocol and the distribution layer — is behind us. The current architecture separates concerns correctly: MCP is the protocol (open, anyone can implement), marketplaces are discovery layers (curated, provider-managed), and function calling/tool use are application-level integration mechanisms (flexible, per-application). Each layer does its job and the combination is more capable than the monolithic Plugins approach ever was.