Skip to content

Skill or MCP Server: Choosing the Right Layer

Decide between a SKILL.md file and an MCP server for a given agent capability. The two are complementary layers, not competitors - skill catalogs (including AgentArmory) deliver skills over MCP itself. Use when the choice between layers is not obvious.

Agent Orchestration|v1|Updated 7/16/2026|License: Proprietary
MCP get_skill({ skillId: "skill-or-mcp-server-choosing-the-right-layer" })

Use this skill with your agent

Create a free account and connect via MCP

Get Started Free
---
title: "Skill or MCP Server: Choosing the Right Layer"
description: "Decide between a SKILL.md file and an MCP server for a given agent capability. The two are complementary layers, not competitors - skill catalogs (including AgentArmory) deliver skills over MCP itself. Use when the choice between layers is not obvious."
author: AgentArmory
license: Proprietary
---

# Skill or MCP Server: Choosing the Right Layer

Decide between a SKILL.md file and an MCP server for a given agent capability. Skills provide procedural knowledge as structured instructions. MCP servers provide runtime tool access. These are **complementary layers, not competitors** - a skill catalog (AgentArmory included) is itself delivered over the MCP protocol, and the most capable agent systems use both together.

This guide uses a 5-question decision framework, a decision matrix, and concrete examples to help agents (and the humans guiding them) choose the right layer for each part of a task.

## Before You Start: Layers, Not Rivals

Skills and MCP servers occupy different architectural layers. A skill encodes *what to do* (methodology, steps, decision rules). An MCP server provides *the means to do it* (tool execution, real-time data, side effects).

The confusion arises because skill catalogs - including AgentArmory - deliver skills through an MCP endpoint. A user authenticates to the catalog, queries for a skill via MCP tools, and receives skill instructions back through the same protocol. This means a single MCP connection can carry BOTH skill discovery AND tool execution. A skill delivered over MCP is not an MCP server - it is still a set of instructions the agent reads and follows. The delivery transport and the capability layer are orthogonal.

| Distinction | What it is |
|-------------|-----------|
| SKILL.md content | Procedural instructions for the agent to follow |
| MCP protocol | Transport layer that carries messages |
| MCP server | Executable that provides tools, resources, prompts |
| Skill catalog (MCP-based) | A service that delivers skill instructions over MCP |

## When to Use

Use when:
- The user asks "should this be an MCP server or a skill?"
- You are deciding how to implement a new capability for an agent
- You are evaluating whether an existing MCP server could be replaced by a skill or vice versa
- You need to explain the difference between skills and MCP to a user
- You are comparing agent tool platforms and need to understand the layer boundaries

## Triggers

"should I use MCP or a skill for this", "MCP vs skill", "skill vs MCP server", "difference between skills and MCP", "when to use MCP server", "when to write a skill", "is this an MCP thing or a skill thing", "how do skills relate to MCP", "complementary layers", "skills vs tools", "choose between skill and MCP"

## How Skills and MCP Differ

| Dimension | Skill (SKILL.md) | MCP Server |
|-----------|-----------------|------------|
| What it provides | Procedural knowledge - instructions, methodology, steps | Execution environment - tools, resources, prompts the agent can call |
| When it runs | Read at context-load time, followed as instructions | Runs as a subprocess or remote service, invoked on demand |
| State | Stateless (instructions only) | Can be stateful (databases, file systems, network services) |
| Auth model | None for raw SKILL.md files; delivered through authenticated MCP transport when served from a skill catalog | May need API keys, tokens, or session auth for its tools |
| Discovery | Requires an agent platform (Hermes, OpenClaw) or a catalog (AgentArmory) to index and serve | Discovered via MCP protocol (list tools, read resources) or listed in registries (Smithery, Glama) |
| Modification | Edit the markdown file | Edit the code, rebuild, redeploy |
| Latency | Zero (instructions are in context) | Network/process overhead per call |

Continue reading

Sign up for a free account to view the full skill content

Login / Register
#MCP#skills#decision-framework#architecture#agent-design#hybrid#complementary-layers#best-practices
License: Proprietary

Related Skills

More skills in Agent Orchestration

Acp Router

Route plain-language requests for Claude Code, Cursor, Copilot, OpenClaw ACP, OpenCode, Gemini CLI, Qwen, Kiro, Kimi, iFlow, Factory Droid, Kilocode, or explicit ACP harness work into either OpenClaw ACP runtime sessions or direct acpx-driven sessions ("telephone game" flow). For coding-agent thread requests, read this skill first, then use only `sessions_spawn` for thread creation. Codex chat binding defaults to the native Codex app-server plugin unless ACP is explicit or background spawn needs ACP.

#broad-capability#browserMIT

Agent Governance

Patterns and techniques for adding governance, safety, and trust controls to AI agent systems. Use this skill when: - Building AI agents that call external tools (APIs, databases, file systems) - Implementing policy-based access controls for agent tool usage - Adding semantic intent classification to detect dangerous prompts - Creating trust scoring systems for multi-agent workflows - Building audit trails for agent actions and decisions - Enforcing rate limits, content filters, or tool restrictions on agents - Working with any agent framework (PydanticAI, CrewAI, OpenAI Agents, LangChain, AutoGen)

#github-copilot#agentMIT

Agentic Development

Build AI agents with Pydantic AI (Python) and Claude SDK (Node.js)

#claude-bootstrap#bootstrapMIT

Agentic Workflows

Route gh-aw workflow design/create/debug/upgrade requests to the right prompts.

#broad-capability#agentic-workflowsMIT

Agent Protocol

Inter-agent communication protocol for C-suite agent teams. Defines invocation syntax, loop prevention, isolation rules, and response formats. Use when C-suite agents need to query each other, coordinate cross-functional analysis, or run board meetings with multiple agent roles.

#work-life#productivityMIT

Agent Safety & Governance

Guidelines for building safe, governed AI agent systems. Apply when writing code that uses agent frameworks, tool-calling LLMs, or multi-agent orchestration to ensure proper safety boundaries, policy enforcement, and auditability.

#github-copilot#deployMIT