What Is an Agent Plugin, Really? The Parts Inside and Three Generations, in Pictures
A plugin does not teach an agent anything new. It is a box. It packs a few parts the agent could already use (a manual, a tool, a small script that runs on its own) together with a name and a version number, so the whole set installs at once and can be handed to someone else. The 2023 generation of plugins was gone within three years; this generation changed approach and stuck. I installed one of my own public plugins and measured it. Each conversation carried 332 more tokens, under 1% of an empty conversation. This post tells the story in pictures; the details are in the in-depth edition.
The story: parts first, then the box
An agent is “a large language model plus a set of tools.” To make it work the way your team works, you add things: a manual for how we do this job, a tool that can query the company database, a little script that formats the code every time something is edited.
All of these existed already, and each worked on its own. The trouble was handing them to someone else: a colleague copied them into their project one by one, and when you changed one, their copy stayed behind. The plugin is the box that appeared for this job.
What is in the box
Click each part to see what it is, when it acts, and whether it takes up room in the conversation:
Three generations
Within three years, the word “plugin” changed meaning. Click “Next” to step through:
Step 1 of 8
2023-03 · ChatGPT plugins
The first generation: a plugin = a web address + an API description. Developers hosted the service on their own servers, passed a review before listing, and only ChatGPT could use it. Early partners included Expedia, Wolfram and Zapier.
Step 2 of 8
2023-06 · Function calling
Models learned to fill in a structured form to call a tool, and called tools far more accurately. But every vendor's form was different, so switching models meant rewriting everything.
Step 3 of 8
2024-04 · The first generation bows out
ChatGPT plugins were switched off in favor of GPTs, launched in 2023-11. The trouble lay mostly in three places: one platform only, a review gate, and a model that often did not know when to call.
Step 4 of 8
2024-11 · MCP, a universal socket
Anthropic open-sourced MCP, which defines how a tool connects to an agent. Write a tool once and any agent can plug it in. OpenAI adopted it in 2025-03.
Step 5 of 8
2025 · More and more parts
Claude Code gained commands, hooks and subagents one after another. Each was useful, but you copied them into a project one at a time, and sharing them was a chore.
Step 6 of 8
2025-10 · Plugins + skills
On 10-09 Claude Code plugins entered public beta: parts packed into one folder, and a git repository is a marketplace. On 10-16 Skills launched, and they soon became the part plugins carry most often.
Step 7 of 8
2025-12 → 2026-01 · Beyond one vendor
Skills became an open standard that Codex, Gemini CLI and Cursor all read. MCP was donated to the Linux Foundation. On 2026-01-30 Cowork, built for people who do not code, gained plugins too.
Step 8 of 8
2026 · Standardizing the box too
In March Codex opened a plugin marketplace with a folder layout copied almost exactly from Claude Code. In August Agent Plugins 1.0, maintained by Amazon, Cursor, Microsoft, OpenAI and Vercel, set out to standardize the box itself; Google joined later.
The two generations share a name and do almost everything the opposite way:
The biggest change is what goes in. A 2023 plugin was “an API, waiting for the model to call it.” A plugin today is mostly “a manual that tells the agent how your team does things,” with tools packed in as a side item.
What I tested
In one sentence: open an empty conversation and see how many tokens it carries with and without a plugin; then make the plugin actually run and watch when each part wakes up.
I used two plugins. One is my public “API relay audit” plugin, which holds a single skill. The other is a lab plugin built for this test, with one skill, one subagent, hooks, one MCP tool and one command. Here is how many extra tokens each conversation carries once they are installed:
The audit plugin’s manual is 17 KB of text, yet installing it added only 332 tokens: what normally sits in the conversation is a table of contents, each part’s name and one-line description. The full text is read only when it is needed.
One run: when does each part wake up
I said “lab hello” to the lab plugin and read the logs:
Step 1 of 6
Work starts
The hook fires once; the small MCP program is started and reports which tools it has. The conversation gains only a few names.
Step 2 of 6
Picking the skill
I had installed a second plugin that also has a skill called hello. The agent read the descriptions and picked the lab plugin's one; each plugin keeps its own names, so the two do not collide.
Step 3 of 6
Only now is the manual read
The skill's full text enters the conversation at this step, and the agent replies with a line as it says.
Step 4 of 6
Before using a tool, fetch its manual
The manual tells it to call the MCP tool. How to use that tool is not normally in the conversation, so the agent looks it up first, then calls it.
Step 5 of 6
The program answers
The program alongside gets the request and replies with one line, "stamp ok", which the agent passes on to me.
Step 6 of 6
The hook is there throughout
The hook fires before every tool use: 3 times in this run, and not a word of it shows in the conversation.
What it means
First: installing more plugins costs little room; the hard part is the one-line description. Each part normally keeps only a name and a description, so ten plugins add up to a few thousand tokens. The flip side: the agent decides whether to use your part from that one line. If the description is vague, the best manual in the world never gets called.
Second: the manual travels; the box does not, yet. Skills are already a format many agents read, but the plugin box is still different from vendor to vendor. I gave Claude Code a package laid out in the vendor-neutral format (Agent Plugins 1.0), and it recognized only the skill:
If you want people to use your work across different agents, write the skill well first; it travels farthest.
Third: people who can write a manual can now make a plugin. In 2023 a plugin meant writing a service and passing a review; today a plugin can be a single manual. I turned two audit workflows from my job into plugins for colleagues, and apart from the manuals they are mostly a few existing scripts. The role-based plugins for Cowork (sales, legal, finance) follow the same idea: writing down how your team works is worth more than writing another API.
Want the details
The in-depth edition, Inside an Agent Plugin, covers what this one leaves out:
- One table of every part: who runs it, when it loads, whether it enters the model’s context
- The full log of that “lab hello” from input to output, including every message the MCP program sent and received
- Why same-named skills in two plugins do not collide, and how versions and marketplaces are written
- What the vendor-neutral format, Claude Code and Codex each recognize, and when to build a plugin versus ship a single skill
- The lab plugin’s complete source and the commands to reproduce it
The previous post in this series, Agents That Check Their Own Work and Tidy Their Own Memory, is about something else: how an agent checks its own work and tidies its own memory.
In one line: a plugin teaches an agent nothing new; it puts what the agent knows into a box you can hand to someone else.