In the Agent era, the most common confusion is not technical — it’s architectural. We keep mixing abstraction layers, and then we end up debating terms that were never meant to be equivalent:
Is a plugin basically an app?
Is a special agent the new app?
What’s the difference between an API and a skill?
Is a general agent a tool, or a platform?
If we don’t separate layers, these questions will keep looping forever. So here’s a clean mental model: a six-layer stack from intent down to execution.
Human Intent → General Agent → Special Agent → Skill → Plugin → API
General Agent is the default entry point and the scheduler. It interprets natural language goals, decomposes complex tasks, decides which specialists to call, determines which capabilities to invoke, sequences execution, and manages permissions. Structurally, it resembles what browsers were in the web era, what desktop operating systems were in the PC era, and what iOS SpringBoard was in mobile: the “front door” where intent is translated into actions. It is not necessarily a specialist — it is the orchestrator.
Special Agents are domain experts: coding agents, math agents, legal agents, research agents, trading agents, and so on. Functionally, they look like “apps” because they are optimized around a task domain — specific knowledge, specific toolchains, and domain-specific execution strategies. But structurally, they are no longer the entry point. In the agent era, the entry point is owned by the General Agent.
Apps belong to the mobile-era abstraction. The traditional loop is user-driven: the user opens an app, navigates a UI, and triggers actions. In the agent era, the loop becomes orchestration-driven: the user expresses intent once, the General Agent dispatches the work, specialists and tools execute, and the result returns. Apps won’t disappear overnight, but many will lose their role as the primary interface. Some will degrade into background capabilities; others will survive as “special agents with UI.”
Then come the lower layers that people often collapse into one.
Skills are capability declarations — a semantic contract the model can understand. They describe what can be done, which parameters are required, what outputs are produced, and which permissions are needed. Skills live in the language layer; they don’t execute code. They exist so the model can plan.
Plugins are execution wrappers — the part that actually runs. They encapsulate API calls or local system access, handle authentication and permissions, manage errors, and return structured results. If skills are “what can be done,” plugins are “how it gets done.”
APIs are the lowest-level interfaces — the protocol surface that exposes underlying systems as callable endpoints. APIs do not think, decide, plan, or schedule. They are passive responders. If you like metaphors: electricity is the capability; the API is the wall socket.
So who is the “new app”?
From a task-function perspective: Special Agent ≈ the new app.
From an entry-point perspective: General Agent ≈ the new operating system.
From an execution-unit perspective: Plugin ≈ the new software primitive.
In other words, the mobile-era “app” is being decomposed into entry-point control, capability interfaces, and execution wrappers. The most strategic control point shifts to orchestration: whoever controls the General Agent controls the new default entry point.
Finally, a quick note on industry evolution. Early agent architectures were plugin-first: LLM + plugins = an executor. OpenAI even explored a “plugin store” storyline, reminiscent of app stores. The reason that pattern didn’t become the dominant ecosystem isn’t that plugins are useless. It’s that plugins are dangerous: they hold real privileges, and in an agent loop they can be triggered automatically, not necessarily by a human click. Discovery and scheduling are also harder when the “buyer” is a model. Most importantly, plugins expand what can be done — but the harder bottleneck is deciding what should be done, in what order, under what constraints.
That is why skills emerged as a lighter semantic layer, and why modern architectures insert governance and orchestration between the model and execution. Plugins didn’t disappear; they moved downward in the stack.
This isn’t “plugins failed.” It’s the software unit migrating. The new game is not only capability — it’s orchestration.
https://liweinlp.com/category/english
