I Thought “Agent Plugin” Meant Something Else
This essay was inspired by:
OpenAI: Introducing Agent Plugins (An introduction to the new open standard for Agent Plugins.)
YouTube: https://youtu.be/UaeWJK_vv-Y
I recommend watching the original video either before or after reading this essay. This essay reconstructs a productive moment of surprise that arose while watching it. It is neither a summary nor a critique of the original, but a reconstruction of a line of thought that it inspired.
An Unexpected Realization
At some point while watching it, I realized that OpenAI meant something different from what I had instinctively assumed when I first heard the term.
This is not a criticism.
On the contrary, the direction they are taking seems both sensible and consistent. Agent Plugins provide a standardized way to equip an agent with capabilities.
My first association, however, was different.
I instinctively interpreted the term Agent Plugin as a portable representation of an entire agent.
Not a package of capabilities.
The agent itself.
I imagine an agent being described in a neutral, portable form:
- Identity
- Role
- Personality
- Working style
- Capabilities
- Tools
- Permissions
- Memory policies
- Communication rules
In short:
An agent as the unit of deployment.
That would allow me to load an agent into any compatible client, much like installing a plugin today.
Not:
“Install this capability.”
But:
“Install Hans.”
Or:
“Install Gudrun.”
From that moment on, the agent would become a participant in the conversation.
I could write:
Hans, please analyze this document.
Or:
Gudrun, what weaknesses do you see in Hans’ proposal?
Or even:
Hans and Gudrun, discuss this among yourselves and come back when you’ve reached an agreement.
What strikes me is that this no longer feels like science fiction.
With MCP servers, standardized tool protocols, and today’s agent runtimes, many of the necessary building blocks already exist.
What still seems to be missing is a neutral description of the agent itself.
Not just its tools.
Its identity.
Perhaps that is the real distinction.
Today, we mostly describe what an agent can do.
I find myself increasingly interested in a different question:
How can an agent itself be described in a way that makes it portable across different runtimes?
This is explicitly not about a particular language model.
Nor is it about a particular vendor.
An agent should be able to preserve its identity even if the underlying model or its available tools change.
The runtime determines how the agent operates.
The agent package defines who it is.
Perhaps my first association was simply different.
Or perhaps it points toward the next level of abstraction.
Not:
Capabilities as plugins.
But:
Agents as plugins.