# Skills vs MCP Servers in the Agent-Battle Workshop: Key Differences Explained

> Understand the core differences between Skills and MCP servers in the agent-battle workshop. Learn how static Skills contrast with dynamic MCP tool APIs to optimize your agent development.

- Repository: [Anthropic/cwc-workshops](https://github.com/anthropics/cwc-workshops)
- Tags: deep-dive
- Published: 2026-07-18

---

**In the anthropics/cwc-workshops agent-battle workshop, Skills are static, file-based instructions that agents read at runtime, while MCP servers are networked HTTP services that expose callable tool APIs returning dynamic data.**

The repository demonstrates a dual-architecture approach for extending agent capabilities. Understanding the distinction between these two components is essential for building effective battle agents that combine persistent knowledge with real-time data access.

## What Are Skills in the Agent-Battle Workshop?

Skills represent **static, reusable capabilities** encoded as markdown files. According to the implementation in [`agent-battle/my_agent.py`](https://github.com/anthropics/cwc-workshops/blob/main/agent-battle/my_agent.py), Skills rely on the built-in `read` tool to load instructions at runtime.

### How Skills Work

A Skill is essentially a documentation file uploaded via the Skills API and attached to the agent configuration. The agent accesses these files on-demand without requiring network calls to external services. As implemented in [`my_agent.py`](https://github.com/anthropics/cwc-workshops/blob/main/my_agent.py) around line 71, the agent uses the comment notation that "Skills are file-based; the agent needs the built-in `read`" to indicate this dependency.

Skills reside in the `skills/` directory structure, following the pattern `skills/<category>/SKILL.md`. Once uploaded, they remain static until explicitly updated, making them ideal for encapsulating stable procedures, coding libraries, or reusable prompt templates.

### Skill Configuration Example

Here is how a Skill file is structured and referenced:

```markdown

# SKILL.md

name: "mining"
version: "latest"
description: |
  Skill that teaches the agent how to mine resources efficiently.
  Provides static instructions for cave navigation and tool selection.

```

Attaching the Skill to an agent configuration:

```json
{
  "model": "claude-3-5-sonnet-20240620",
  "system_prompt": "You are a Minecraft automation agent.",
  "skills": ["skills/mining/SKILL.md"]
}

```

## What Are MCP Servers in the Agent-Battle Workshop?

**MCP (Model Context Protocol) servers** provide dynamic, callable tool endpoints that agents invoke over HTTP. Unlike the static nature of Skills, MCP servers execute logic and return fresh data with each request.

### MCP Server Architecture

The workshop implements MCP servers as lightweight HTTP JSON-RPC services. In [`agent-battle/my_agent.py`](https://github.com/anthropics/cwc-workshops/blob/main/agent-battle/my_agent.py) at line 73, the configuration references `MCP_MINECRAFT_WIKI` as "an MCP server with one tool: `lookup(query) → fact`". This definition points to a live service capable of querying external data sources.

The actual implementation resides in `agent-battle/event/lib/wiki.mjs`, which exports a tool schema defining the `lookup` function:

```javascript
// agent-battle/event/lib/wiki.mjs
export const wikiMcp = {
  tools: [
    {
      name: "lookup",
      description: "Lookup a fact in the Minecraft wiki.",
      input_schema: { 
        type: "object", 
        properties: { 
          query: { type: "string" } 
        } 
      },
      output_schema: { 
        type: "object", 
        properties: { 
          fact: { type: "string" } 
        } 
      }
    }
  ],
  async handler(toolName, args) {
    if (toolName === "lookup") {
      // Live data retrieval logic
      return { fact: `The diamond ore is found below Y-level 16.` };
    }
  }
};

```

### MCP Endpoint Registration

MCP servers are hosted either centrally by the event server (`event/server.mjs`) or as per-bot endpoints. Registration occurs through environment configuration in [`setup.sh`](https://github.com/anthropics/cwc-workshops/blob/main/setup.sh):

```bash

# Registering bot-specific MCP endpoint

export BOT_MCP_URL="${RELAY_URL%/}/p/${RELAY_KEY}/mcp"

```

The `event/server.mjs` file handles routing for both the wiki MCP (`/wiki/mcp`) and individual bot endpoints (`/p/<key>/mcp`), enabling distributed tool access during agent battles.

## Key Differences Between Skills and MCP Servers

| Aspect | Skills | MCP Servers |
|--------|--------|-------------|
| **Nature** | Static markdown files | Runtime HTTP services |
| **Access Method** | `read` tool (file system) | `mcp_toolset` / HTTP JSON-RPC calls |
| **Data Freshness** | Updated only on re-upload | Dynamic responses on every call |
| **Primary Use Case** | Reusable prompts, procedures, libraries | Live data lookups, external APIs |
| **Deployment** | Uploaded via Skills API, attached to config | Served via `event/server.mjs` or bot-specific endpoints |

## Implementation Comparison

When building an agent in the workshop, you combine both approaches. **Skills** provide the foundational knowledge (how to craft items, navigation strategies), while **MCP servers** provide situational awareness (current player positions, wiki lookups).

The [`agent-battle/README.md`](https://github.com/anthropics/cwc-workshops/blob/main/agent-battle/README.md) describes this architecture as combining model + system prompt + *skills* + *MCP tools*, emphasizing that Skills supply reference material while MCP servers supply computational capabilities.

## Summary

- **Skills** are static [`SKILL.md`](https://github.com/anthropics/cwc-workshops/blob/main/SKILL.md) files accessed via the `read` tool, uploaded once through the Skills API, and ideal for reusable instructions.
- **MCP servers** are HTTP JSON-RPC endpoints defined in files like `event/lib/wiki.mjs`, registered in [`setup.sh`](https://github.com/anthropics/cwc-workshops/blob/main/setup.sh), and hosted by `event/server.mjs` to provide dynamic tool calls.
- Skills require no network infrastructure; MCP servers require active endpoint hosting and return live data.
- The agent configuration in [`my_agent.py`](https://github.com/anthropics/cwc-workshops/blob/main/my_agent.py) demonstrates both patterns: static Skills for baseline capabilities and `MCP_MINECRAFT_WIKI` for real-time wiki queries.

## Frequently Asked Questions

### Can an agent use both Skills and MCP servers simultaneously?

Yes. The workshop architecture specifically supports hybrid configurations where agents reference Skills for static knowledge bases while calling MCP servers for dynamic operations. The [`my_agent.py`](https://github.com/anthropics/cwc-workshops/blob/main/my_agent.py) implementation demonstrates this by loading Skills via the `read` tool while simultaneously configuring the `MCP_MINECRAFT_WIKI` endpoint for live lookups.

### How do I update a Skill compared to updating an MCP server?

Updating a Skill requires re-uploading the [`SKILL.md`](https://github.com/anthropics/cwc-workshops/blob/main/SKILL.md) file via the Skills API and updating the agent's configuration to reference the new version. MCP servers update transparently—modifying the server code in `event/lib/wiki.mjs` or restarting the service immediately affects all subsequent tool calls without changing agent configuration.

### Why would I choose an MCP server over a Skill for my agent?

Choose an MCP server when your agent needs access to changing data, external APIs, or computational tools that cannot be expressed as static instructions. For example, querying the Minecraft wiki for block properties requires an MCP server because the information might update or require search functionality. Use Skills for stable knowledge like crafting recipes or established procedures that do not require runtime calculation.

### Where are MCP servers hosted in the workshop infrastructure?

The workshop supports two hosting patterns. The event server (`event/server.mjs`) hosts shared MCP services like the wiki lookup at `/wiki/mcp`. Individual bots can also host dedicated endpoints registered via `BOT_MCP_URL` in [`setup.sh`](https://github.com/anthropics/cwc-workshops/blob/main/setup.sh), enabling agent-specific tools accessible at `/p/${RELAY_KEY}/mcp`.