Agent Plugins: MCP + Skills in One Package

R-report

Agent Plugins: MCP + Skills in One Package

AI coding agents are becoming increasingly capable. They can connect to databases, inspect projects, use external tools, and follow specialized instructions.

But there is a practical problem.

Giving an agent **access to a tool** and teaching it **how to use that tool well** have largely been handled separately.

A new open standard called **Agent Plugins** aims to bring these two pieces together.

The basic idea is surprisingly simple:

**MCP = Access** **Skills = Knowledge** **Agent Plugin = Access + Knowledge**

What Is an Agent Plugin?

An Agent Plugin is essentially a folder organized according to a standard structure.

Inside that package, developers can combine the resources an AI agent needs to work effectively with a particular technology.

Compatible AI coding tools can then load the same package instead of requiring developers to configure everything separately for every agent.

For example, the same plugin can be used with compatible tools such as **Cursor** and **Codex**.

At the time of the original guide, Claude / Anthropic does not support the Agent Plugins standard.

The important point is that Agent Plugins do not necessarily introduce entirely new AI capabilities.

Instead, they provide a **standardized way to package existing capabilities together.**

The Two Pieces of an Agent Plugin

The easiest way to understand Agent Plugins is to separate them into two complementary parts.

1. MCP — Access

MCP, or Model Context Protocol, connects an AI agent to external systems and tools.

Think of MCP as answering the question:

**What can this agent access?**

Without a connection, an AI coding agent may understand what Supabase is, but it cannot necessarily interact with your actual Supabase environment.

MCP provides that bridge.

Conceptually:

**AI Agent → MCP → External Tool**

This gives the agent the ability to interact with systems beyond the model itself.

But access alone creates another problem.

The agent may be able to use the tool without necessarily knowing the best way to use it.

That's where Skills come in.

2. Skills — Knowledge

Skills provide specialized instructions and knowledge to an AI agent.

Think of Skills as answering:

**How should the agent use this tool?**

An agent might need to understand:

• recommended workflows,

• project conventions,

• tool-specific instructions,

• common patterns,

• or best practices.

This information helps the agent behave less like someone discovering a tool for the first time and more like someone who already understands how it should be used.

Conceptually:

**MCP gives the agent access.**

**Skills give the agent knowledge.**

These are different capabilities, but in practice they often belong together.

Why Combine MCP and Skills?

Imagine hiring a new developer.

You give them credentials to your development systems.

They now have **access**.

But that doesn't mean they know:

• how your team works,

• which workflows to follow,

• which conventions matter,

• or how a particular system should be used.

They still need documentation and instructions.

AI agents face a similar problem.

MCP can give the agent access to a system.

Skills can explain how to work with that system.

Agent Plugins package these two pieces together:

**Access + Knowledge**

↓

**Agent Plugin**

That packaging is the important innovation.

One Package, Multiple AI Tools

Without a common format, developers may need to configure similar capabilities separately across different AI coding environments.

That becomes increasingly inconvenient as developers use multiple agents.

For example:

**Cursor configuration**

**Codex configuration**

**Other agent configuration**

Each environment may need similar tools and similar instructions.

Agent Plugins introduce a more portable model.

Instead of thinking:

“How do I configure Supabase for each AI coding tool?”

the idea becomes:

“Install the Supabase plugin.”

Compatible tools can then load the standardized package.

This can make agent capabilities easier to:

**Install · Share · Maintain · Reuse**

Example: The Supabase Agent Plugin

Supabase already provides an Agent Plugin.

It can be installed with:

npx plugins add supabase-community/supabase-plugin

The plugin packages complementary capabilities for agents working with Supabase.

Instead of manually treating access and specialized knowledge as completely separate pieces, the plugin provides a common package that compatible AI coding tools can consume.

For developers who regularly move between coding agents, this can reduce repeated setup.

Before and After Agent Plugins

The difference can be understood simply.

Before

You might manage:

**MCP**

for access to external systems,

plus:

**Skills**

for specialized instructions,

plus potentially:

**different configurations for different AI tools.**

The pieces work, but they are fragmented.

With Agent Plugins

Those capabilities can be distributed as:

**One standardized plugin package**

The underlying technologies haven't disappeared.

MCP is still MCP.

Skills are still Skills.

The plugin simply gives developers a cleaner way to package and distribute them together.

Why This Could Matter for AI Coding

Today's AI coding tools are rapidly becoming more than code-completion assistants.

They increasingly operate as **agents**.

An agent may need to:

• understand a project,

• access external services,

• follow development conventions,

• use specialized tools,

• and perform multi-step tasks.

As agents become more capable, configuring each capability manually becomes increasingly cumbersome.

A standardized plugin ecosystem could make agent capabilities more portable.

Instead of rebuilding the same setup for every AI coding environment, developers could install reusable capability packages.

It resembles what package managers did for software dependencies:

**Find → Install → Use**

Agent Plugins could bring a similar mental model to AI agent capabilities.

A Simple Mental Model

The easiest way to remember the concept is:

MCP = Access

**“What can I connect to?”**

↓

Skills = Knowledge

**“How should I work with it?”**

↓

Agent Plugin = Package

**“Give my agent both.”**

Another way to think about it:

**MCP gives the agent the keys.**

**Skills give the agent the manual.**

**Agent Plugins put the keys and manual in the same box.**

The Bigger Shift

The interesting part isn't simply another plugin format.

It points toward a broader change in AI development.

Today, developers often configure AI tools individually.

In the future, we may increasingly configure **capabilities** that can move between compatible agents.

Instead of:

**Configure every agent separately**

the model becomes:

**Package a capability once → Use it across agents**

If that ecosystem develops, switching between AI coding tools could become much easier because the agent's tools and specialized knowledge would no longer need to be rebuilt from scratch every time.

Key Takeaway

Agent Plugins combine two things that AI agents frequently need together:

**MCP → Access**

**Skills → Knowledge**

into:

**Agent Plugin → Access + Knowledge**

The technologies themselves aren't new.

What's new is the standardized packaging.

And that seemingly small change could make AI agent capabilities significantly easier to **install, share, maintain, and reuse across compatible tools.**