How MCP Skills Work Together with AI Agents: Full Guide

Understanding how MCP skills work under the hood changed how I debug problems and design setups. You don't need to know this to use skills — but once you do, you'll never be confused by a broken config again.

The Architecture in One Diagram

┌─────────────────────────────────────────────────────────┐
│                    TrustedSkills Registry                │
│  skill: weather · npm: @trustedskills/weather-mcp       │
└───────────────────────┬─────────────────────────────────┘
                        │ (1) You discover the skill
                        ▼
┌─────────────────────────────────────────────────────────┐
│                  AI Client Config                        │
│  { "mcpServers": { "weather": {                         │
│      "command": "npx",                                  │
│      "args": ["-y", "@trustedskills/weather-mcp"] } } } │
└───────────────────────┬─────────────────────────────────┘
                        │ (2) Client starts MCP server as subprocess
                        ▼
┌─────────────────────────────────────────────────────────┐
│                  MCP Server Process                      │
│  npx @trustedskills/weather-mcp                         │
│  Listens on stdio · Exposes:                            │
│    get_weather(location, units)                          │
│    get_forecast(location, days)                          │
└───────────────────────┬─────────────────────────────────┘
                        │ (3) Client discovers tools
                        ▼
┌─────────────────────────────────────────────────────────┐
│                  Claude                                  │
│  "What's the weather in Sydney?"                        │
│  → calls get_weather({ location: "Sydney" })            │
└─────────────────────────────────────────────────────────┘

The Full Lifecycle, Step by Step

Step 1: Discovery

You browse TrustedSkills, find a skill that does what you need. Each listing shows you the tools it exposes and the exact config JSON to copy.

Step 2: Configuration

Paste that JSON into your AI client's config file. For Claude Desktop it's claude_desktop_config.json. The config just tells the client: "when you start up, run this command."

Step 3: Server Launch

When you restart the AI client, it reads the config and launches each MCP server as a child process. That's literally what npx -y @package/name is doing — the client runs it as a subprocess and connects via stdio.

Step 4: Tool Discovery

The client sends the server a message: "what tools do you have?" The server responds with a JSON list of tool definitions. Here's what that looks like:

{
  "tools": [
    {
      "name": "get_weather",
      "description": "Get current weather for a location",
      "inputSchema": {
        "type": "object",
        "properties": {
          "location": { "type": "string" },
          "units": { "type": "string", "enum": ["metric", "imperial"] }
        },
        "required": ["location"]
      }
    }
  ]
}

Step 5: Tool Calling

User asks something. Claude decides a tool is relevant and calls it:

{
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": { "location": "Sydney", "units": "metric" }
  }
}

Step 6: Result

The server does the work — calls an API, reads a file, queries a database — and returns the result. Claude uses it to form a response. You see a helpful answer; the JSON flew by invisibly.

Skill vs MCP Server: What's the Real Difference?

How the Protocol Works (the Short Version)

MCP uses JSON-RPC 2.0 over stdio. No HTTP server. No ports. The client writes JSON to the server's stdin; the server writes JSON to its stdout. That's the whole protocol.

It's simple by design — works the same on Mac, Windows, and Linux. No firewall rules, no network configuration, no port conflicts. The subprocess is isolated to process-level communication only.

Some advanced setups use SSE (Server-Sent Events) over HTTP for remote MCP servers, but that's uncommon for skills installed from TrustedSkills.

End-to-End Example: Weather Skill

You ask Claude Desktop: "What's the weather in Tokyo?"

1. Weather MCP server is running (launched from your config)
2. Claude sees the get_weather tool is available
3. Claude decides this query needs that tool
4. It calls get_weather({ location: "Tokyo", units: "metric" })
5. The MCP server calls the Open-Meteo API
6. Returns: { temperature: 18, condition: "Partly cloudy" }
7. Claude gives you a natural-language answer using that data

Total time: under a second. Feels like magic; it's just well-designed plumbing.

Frequently Asked Questions

How does Claude know when to use an MCP tool?

The tool definitions include a name and description. Claude reads those and decides whether a tool is relevant to what you're asking. The better the tool description, the more reliably Claude uses it at the right moment.

Can MCP skills access my local files?

Only if they're designed to. A filesystem skill can access files; a weather skill can't. Each skill only does what its tools define. This is why checking a skill's verification status matters before installing it.

What happens when an MCP server crashes?

Claude will stop offering that skill's tools and may show an error. Restart your AI client to relaunch the server. Claude Desktop shows crash details in Settings → Developer → MCP Logs.

Can I run many MCP skills simultaneously?

Yes. Each skill runs as a separate subprocess. You can have dozens running at once — Claude picks whichever tools are most relevant for each query.