Skills vs MCP vs Tools vs Plugins: What's Actually the Difference for AI Agents in 2026?

TL;DR: Tool use is the API primitive ("the model calls a function"); MCP is a protocol that turns any external service into a tool source the model can connect to; Claude Skills are packaged instructions (markdown + optional code/data) that teach the model how to do a specific task well; OpenAI Apps in ChatGPT and the GPT Store's GPTs/Actions are the equivalent surface on the OpenAI side. They're not competing — they stack. This post puts the four in a single mental model, shows where each one shines, and gives the picking rules for builders.

If you've read launch posts from Anthropic, OpenAI, GitHub, Cursor, and a half-dozen agent platforms in 2025, you've seen the same word — "skills," "tools," "actions," "plugins," "connectors," "MCP servers" — used to mean almost-but-not-quite the same thing. This is the disambiguation. For the loop these all plug into, see the agentic loop, explained and the pillar guide on agentic loops.

The base layer: tool use (function calling)

Tool use is the API primitive. The model is given a list of tools — each is a JSON schema with a name, description, and parameters — and emits a structured call: {"tool": "send_email", "args": {...}}. The runtime (your code, or the platform) executes the call and feeds the result back into the model's context. Repeat.

This is the original capability. Anthropic's tool-use docs and OpenAI's function-calling docs describe the same idea with different wire formats. Everything below is built on this.

Two important properties of tool use:

• You ship the schemas. The model sees the tool list in its context window every turn (one of the seven context slots). Ten tools is cheap; a hundred is expensive and degrades selection.
• The model decides which tool, and when. Tools don't run themselves. The model's instructions plus the situation drive selection.

If you only learn one of these layers, learn this one. The others all bottom out here.

MCP: a protocol for connecting tool sources

Model Context Protocol (MCP) is Anthropic's open standard, launched in late 2024 and adopted across the industry in 2025. It answers a different question than tool use: not "how does the model call a function?" but "how does an agent app discover and connect to tools that live somewhere else?"

An MCP server exposes tools (and resources and prompts) over a standard protocol. An MCP client — Claude Desktop, Claude Code, Cursor, ChatGPT (added support in 2025), or any custom agent — connects to the server, lists what's available, and lets the model call those tools as if they were native.

The win: integrations stop being one-off. Instead of every agent platform writing custom code to talk to Slack, GitHub, Notion, and Stripe, each of those services (or a community) ships an MCP server, and every MCP-compatible client gets the integration for free. By mid-2025, GitHub, Slack, Linear, Notion, Cloudflare, and dozens of others had official MCP servers; community servers exist for almost everything else.

When to think about MCP:

• You want your agent to access many third-party services and don't want to write a glue layer for each.
• You're building an agent platform and want to inherit the ecosystem of existing servers.
• You want users to bring their own integrations without you shipping new code.

MCP is a protocol, not a feature. It doesn't add a new model capability — under the hood, the model still calls tools. It standardizes the plumbing.

Skills: packaged instructions for a task

Claude Skills (launched October 2025) are the newer wrapper, and they answer yet a different question: "how do I teach the model how to do a specific task well, in a way I can reuse?"

A skill is a small folder: a SKILL.md with instructions, optional reference files (a style guide, a checklist, a corpus), and optional executable code (a script the model can run). When the user (or the orchestrator) invokes the skill, Anthropic's runtime injects the skill's content into the model's context — instructions, examples, references — for that task.

The mental model: a tool is a thing the model can do; a skill is a way the model knows to do it. "Send an email" is a tool. "Draft a sales follow-up email in our house voice using the AIDA framework, with a soft CTA, under 120 words" is a skill. Skills can wrap tool calls (a skill that uses the gmail_send tool), pure prompting (a skill for editorial tone), or executable workflows (a skill that runs a Python script to format a CSV).

The reason skills caught on: they're shareable. A skill folder lives in git. A team can ship a customer-response-skill to every analyst on Claude; a vendor can ship a excel-builder-skill that gets cited by name. Anthropic, GitHub, and the community have already published dozens for Claude Code.

OpenAI's equivalents in this surface are Apps in ChatGPT (the 2024 plugin surface, refactored), Custom GPTs (instructional + tool-use packaged for the GPT Store), and Operator-style agents. The naming is more fragmented but the idea — packaged instruction + optional tools — converges.

Plugins, Actions, Connectors — the legacy names

"Plugin" mostly refers to the original 2023 ChatGPT Plugins (deprecated and absorbed into Custom GPTs and Apps in ChatGPT). "Actions" is the term Custom GPTs use for tool calls. "Connectors" is what Anthropic calls Claude's hosted integrations (Google Drive, Gmail) — under the hood, MCP-style integrations exposed in the Claude UI.

These overlap. The clean mapping in 2026:

If you're picking what to build, ignore the legacy names and pick from: tool use, MCP, skills.

How they stack — the picking rules

For most agents you'll use all three. Here's the rule of thumb production teams converged on through 2025:

• Tool use is the contract between the model and code. Always present. Even MCP and skills ultimately call tools.
• MCP is how you bring external tools into the agent. If the integration already exists in MCP, use the server instead of writing a custom tool.
• Skills are how you teach the agent a repeatable task. Use them when you'd otherwise paste the same long instructions into every prompt.

Concrete examples:

Building a customer support agent. Tool use defines the contract (search_kb, create_ticket, escalate). MCP gives you Zendesk + Slack + your data warehouse without custom integrations. Skills package the playbook (refund-under-fifty-dollars-skill, enterprise-escalation-skill) with the exact wording and steps.

Building an internal coding agent. Tool use defines what the agent can run (run_tests, read_file, edit_file). MCP brings in GitHub, Linear, and your CI provider. Skills capture team norms (hotfix-release-skill, code-review-skill) so the agent doesn't re-derive your style from scratch each run.

Building a marketing agent. Tool use defines generate_ad_variants, push_to_meta. MCP gives you Klaviyo, HubSpot, and Mixpanel. Skills package brand-voice and approval workflows (brand-voice-skill, legal-review-skill).

Common confusions to avoid

"Should I use MCP or just write a tool?" If the integration exists as an MCP server and you trust it, use the server — you inherit updates and the ecosystem. If the tool is custom to your product (your own internal API, a private DB), write it as a native tool. You can mix both in the same agent.

"Are skills just system prompts?" Skills are richer: instructions plus optional examples, reference files, and executable code. A system prompt is a single string. A skill is a folder. When all you need is one paragraph, use a system prompt; when you need a checklist, examples, and a helper script, ship a skill.

"Do I need MCP if I'm building one agent?" No. If you have five tools and they're all yours, native tool use is the simplest path. MCP shines when you have many tools, external tools, or want users to bring their own.

"Will OpenAI adopt MCP?" They did, in March 2025. Claude was first; OpenAI's Agents SDK and the ChatGPT desktop app now both support MCP. Cursor, Windsurf, Cline, Goose, and most agent IDEs ship MCP client support too. It's effectively a cross-vendor standard now.

The 2026 picture

The four layers — tool use as the primitive, MCP as the integration protocol, skills as the packaged playbook, and the GPT/App stores as the distribution surface — finally stopped competing through 2025 and started composing. An agent built this year typically uses all four: native tool use for its own functions, MCP servers for the long tail of third-party integrations, skills for repeatable team workflows, and an app/skill listing for distribution.

The picking rule, one sentence: tools say what the agent can do, MCP says where the tools come from, and skills say how it should do them. Build any one of them well and you're ahead of most teams. Build all three well and you've got a production agent.

Further reading

• Anthropic — Skills launch post
• Anthropic — Model Context Protocol (official spec + servers)
• Anthropic — Tool use docs
• OpenAI — Function calling guide
• OpenAI — MCP support announcement

For the loop these all run inside, see agentic loops. For the related context window discipline, see context engineering for AI agents. For the older but still-useful MCP integration patterns post, see AI agent integration patterns.