ChatGPT Plugins vs MCP: What Changed and What to Use Now

ChatGPT plugins are gone. They stopped working on April 9, 2024, and nothing shaped like them has come back since. What came back instead is a bigger idea: the Model Context Protocol (MCP), an open standard that lets a single tool server talk to ChatGPT, Claude, Gemini and a long list of other assistants. If you built a plugin in 2023, or you are about to wire up your first AI integration today, the question is simple: what changed, and what should you use now?

This article gives you the dates, a side by side table, a plain-English look at how MCP works and a short decision list. Every section ends with something you can act on.

What ChatGPT Plugins Actually Were

Plugins launched in beta in March 2023 as the first official way to let ChatGPT call outside services: flight search, restaurant booking, a math engine, a shopping assistant. For roughly a year they were OpenAI's main answer to the question "how does ChatGPT reach my data?" Then they were retired.

How a Plugin Worked

A plugin was a small web service plus two files. The first, ai-plugin.json, sat at a fixed address on your domain and gave ChatGPT the plugin's name and a plain-English description. The second was an OpenAPI specification listing every endpoint the plugin offered. ChatGPT read the descriptions, decided when a user request matched, called your endpoint and wove the response into its answer.

The user side was manual. You opened the plugin store, installed a plugin and switched it on for the conversation, with a limit of three active plugins at a time, because every description took up room in the prompt.

That design had four traits worth remembering:

• One platform. A plugin only worked inside ChatGPT.
• One direction. The model called your API and that was the whole conversation.
• Manual setup. Each person picked and enabled plugins by hand.
• Prompt budget. Descriptions competed for a limited amount of context.

💡 Tip: A plugin manifest was basically a pitch written for the model. The clearer your description, the more often ChatGPT picked your endpoint. MCP tool descriptions work the same way, so good writing still pays off.

Why They Faded Out

The reasons were practical rather than dramatic. Finding a good plugin in a store was hit and miss. Every plugin was a one-off integration written for a single assistant. Models also got better at calling functions directly, and custom GPTs arrived in November 2023, bundling instructions, files and Actions into one shareable object that nobody had to assemble by hand.

The calendar was short. Plugins accepted no new conversations after March 19, 2024, and on April 9, 2024 existing plugin conversations stopped working too. If you had a plugin in production, that date was the end of it.

The Timeline From Plugins to Apps

The path from plugins to today's setup has more steps than most summaries admit. Here are the dated milestones.

GPTs and Actions Took Over

A custom GPT let a creator write instructions, attach knowledge files and add Actions, which are API calls described with OpenAPI, the same format plugins used. In that sense Actions were plugins in a friendlier wrapper. The user no longer assembled anything: they opened a finished GPT and talked to it. The catch stayed the same. A GPT lived inside ChatGPT and nowhere else.

MCP Arrives From Anthropic

Anthropic introduced MCP in November 2024 as an open standard for connecting AI systems to tools and data. The pitch was simple: instead of writing one integration per assistant, write one server that any compatible assistant can use. Picture a single universal port replacing a drawer full of chargers.

OpenAI Adopts MCP

In March 2025 OpenAI adopted the protocol, and during 2025 it also launched connectors for work data such as Gmail, Google Drive and Microsoft 365. Support spread fast: MCP is now integrated into ChatGPT, Claude, Gemini, Microsoft Copilot, Cursor and Visual Studio Code. When the project moved to the Linux Foundation in December 2025, it reported more than 10,000 active servers and over 97 million monthly SDK downloads.

Apps and the Plugin Directory

At DevDay on October 6, 2025, OpenAI announced Apps in ChatGPT, built on the Apps SDK, which in turn builds on MCP. Then on July 9, 2026, the App Directory became the Plugin Directory. A plugin now bundles skills, apps and app templates, while apps remain the integrations that connect ChatGPT or Codex to outside data and actions. Existing app connections kept working, and every existing app was packaged into a plugin.

💡 Watch the vocabulary: the word "plugin" is back, but the meaning moved. Today a plugin is a bundle of skills, apps and templates, not an OpenAPI manifest. If a tutorial describes ai-plugin.json, it is describing the 2023 system.

How MCP Works Under the Hood

MCP sounds abstract until you see its three parts and what a server can offer.

Hosts, Clients and Servers

• Host: the app you talk to, such as ChatGPT, Claude or a code editor.
• Client: a connector inside the host that keeps one connection to one server.
• Server: the program that exposes your tools and data.

Messages travel as JSON-RPC 2.0. A server can run as a local process over stdio, or as a remote service over Streamable HTTP, which is how hosted assistants reach it.

Tools, Resources and Prompts

A server offers up to three kinds of things:

1. Tools: actions the model can call, like create_invoice or generate_image.
2. Resources: data the model or the user can read, like a file, a record or a log.
3. Prompts: reusable templates a user can trigger on purpose.

Plugins offered only the first kind, and only as plain HTTP endpoints. That gap is the biggest practical difference between the two.

What the 2026 Spec Changed

The specification revision dated July 28, 2026 is the largest shift since launch. Its main changes:

• Stateless core. No initialize handshake and no session IDs. Each request describes itself, so any server instance behind a load balancer can answer it.
• Header routing. Method and tool names travel in Mcp-Method and Mcp-Name headers, so gateways and firewalls can route and authorize without reading JSON bodies.
• Multi round-trip requests. A server can ask the user for a confirmation or a missing value mid-call without holding a stream open.
• Cacheable lists. Results carry ttlMs and cacheScope values so clients can cache tool lists.
• Tighter authorization. Client ID Metadata Documents are preferred over Dynamic Client Registration, which is deprecated for new implementations.
• Extensions. Tasks, first introduced in the 2025-11-25 revision, and MCP Apps now sit in a formal extensions framework.

💡 Before you upgrade: if your server was written against an earlier revision, read your SDK's release notes first. The stateless change touches how session state is handled.

ChatGPT Plugins vs MCP Side by Side

The Comparison Table

What Plugin Thinking Got Right

Not everything from 2023 was wasted. Plugin authors picked up three habits that carry over directly:

• Narrow endpoints beat giant ones. A tool that does one thing is easier for a model to choose.
• Descriptions are part of the product. Write them for the model, in plain words, with an example.
• An OpenAPI spec is a head start. Each operation maps neatly to one MCP tool, so a documented API is already most of the way there.

What to Use Now

The short answer: build on MCP, and use the Plugin Directory to reach ChatGPT users. The longer answer depends on which side of the table you sit on.

If You Build Tools

Write an MCP server. One server reaches every assistant that speaks the protocol, and the same code can feed a ChatGPT app. A sensible build order:

1. Pick 3 to 7 actions. Fewer, sharper tools get chosen more reliably.
2. Name tools with verbs. search_orders beats orders.
3. Write descriptions for the model. Say when to use the tool and when not to.
4. Add OAuth for anything personal. Never ship user data behind a shared secret.
5. Test in two clients. A server that works in only one host is a plugin in disguise.
6. Deploy remotely over HTTPS. Local stdio is fine for development, not for hosted assistants.

If you want an interactive screen inside ChatGPT, such as a form or a chart, look at the Apps SDK and the MCP Apps extension rather than inventing your own UI layer.

If You Only Use Tools

You rarely need to touch MCP yourself. In ChatGPT, open the Plugin Directory, pick a plugin and connect the app behind it. In Claude, Cursor or VS Code, add an MCP server from the client's settings. Existing app connections made before the July 2026 rename were not affected.

Use this table to choose:

💡 Rule of thumb: if a plugin manifest is all you have, do not port it line by line. Rebuild the three or four useful actions as MCP tools and rewrite the descriptions.

Draft Tool Descriptions With an LLM

Descriptions decide whether a model picks your tool, and a language model is good at tightening them. On PicassoIA you can do it with Claude Sonnet 5:

1. Open the Claude Sonnet 5 page and paste your endpoint list or OpenAPI paths.
2. Ask for one tool name, one description and one example call per endpoint.
3. Tell it to add a "do not use this when" line to each description.
4. Test the output in your MCP client and trim anything vague.

Other models worth trying for the same job are GPT 5.6 Sol for structured output and Gemini 3.5 Flash when you want fast drafts. For agent-style work, Kimi K2.6 is built around tool use and code.

Security Still Matters

A tool is an action, and an action can do damage. MCP gives you better plumbing than plugins did, but it does not make a careless server safe.

• Start read-only. Add write actions one at a time.
• Ask before destructive steps. The multi round-trip feature lets a server request a confirmation in the middle of a call.
• Scope tokens narrowly. Grant the minimum permission each tool needs.
• Treat tool output as untrusted. A web page or a document returned by a tool can carry hidden instructions meant for the model.
• Log every call. When something goes wrong, you want a trail.
• Prefer current authorization. Use pre-registered clients or Client ID Metadata Documents, since Dynamic Client Registration is on its way out.

Try It Yourself on PicassoIA

MCP is easiest to appreciate when you watch it do real work. PicassoIA exposes image and video generation to MCP clients, so an assistant can ask for a picture the same way it asks for any other tool. The pattern is worth noticing: a request returns an ID right away, and the client polls until the result is ready. That create-then-poll rhythm is the same one the Tasks extension was designed around, and PicassoIA allows up to 5 concurrent predictions per account.

You can also try the generators directly in the browser:

• PicassoIA Image for fast photorealistic images from a short prompt.
• PicassoIA Image Editor Pro for editing an existing picture with plain-English instructions.
• Seedream 4.5 for detailed, high-resolution scenes.
• Flux 2 Pro for sharp, controllable compositions.

Pick one, describe a scene in two sentences and compare the result with what you imagined. Then change one detail, the lighting or the lens or the angle, and run it again. Ten minutes of that teaches you more about prompting than any article, and the habit carries straight over to writing good tool descriptions. Head to picassoia.com and make your first image today.