English
← Back to Home

MCP / Agent / Skill / Harness

An editorial map of related agent-application concepts

MCP, Agent, Skill, and Harness describe different concerns in agent applications: context exchange, task execution, reusable instructions, and the host runtime. This four-part view is Aphrodite’s editorial model, not a universal industry architecture or a claim that every product implements all four.

Last reviewed: . Current MCP architecture (2026-07-28).

  1. Claude Code
    1. Harness
      1. Skill
      2. Agent
      3. Tool
      1. MCP
        1. External Tools / Data
🔗

MCP - Model Context Protocol

Connection Layer Protocol

MCP is an open client-server protocol for exchanging context between AI applications and external systems. Hosts coordinate one or more clients; servers expose authorized capabilities such as tools, resources, and prompts. MCP does not define model training, inference, or an agent’s internal reasoning loop.

What is MCP?

MCP is a communication protocol that defines how AI can:

  • Request to execute an operation
  • Get external data
  • Interact with local applications

How it works

  1. An MCP client connects to a local process or remote service
  2. Client and server exchange JSON-RPC requests, responses, and notifications
  3. The server accesses authorized tools, resources, or prompts
  4. The client exposes the normalized result to the model or host interface

Configuration example

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/Projects"]
    },
    "git": {
      "command": "uvx",
      "args": ["mcp-server-git", "--repository", "/Users/you/Projects/example"]
    }
  }
}

Windows may require invoking npx through cmd /c. Configuration paths differ among Claude Desktop, Claude Code, Codex, and Cursor. Verified against the official MCP repository on 2026-07-29.

Official reference servers

Steering Group reference servers (official repository):

  • Everything
  • Fetch
  • Filesystem
  • Git
  • Memory
  • Sequential Thinking
  • Time

These are educational reference implementations, not automatically production-ready. Use the MCP Registry to discover third-party servers, and evaluate publisher identity, permissions, security, and maintenance before adoption. Archived servers and vendor or community servers are separate categories.

🤖

Agent - AI Agent

Task Execution Layer

Agent is an AI system capable of autonomously planning and executing complex tasks. Unlike simple Q&A, Agent can: understand goals → make plans → take actions → evaluate results → adjust strategy.

Core capabilities

  • Understand complex instructions
  • Break large tasks into small steps
  • Autonomously decide next steps
  • Use tools to complete operations
  • Learn from execution results

Usage example

Claude Agent Conversation Example

User: Help me refactor the error handling in this project

Claude Agent:

I’ll help you refactor the error handling. Let me first analyze the current code structure…

  1. Scan error handling code in the project
  2. Identify repeated patterns
  3. Design unified error handling approach
  4. Implement refactoring module by module
  5. Run tests to ensure nothing is broken

[Agent autonomously executes all above steps]

vs GitHub Copilot

Claude Code and GitHub Copilot both provide agentic coding and code-review capabilities in terminal or IDE surfaces. Support for permission confirmation, sandboxing, model choice, cloud asynchronous tasks, and MCP varies by product, client, and version. Distinguish local review from pull-request review and consult current product documentation.

Last reviewed: . Sources: Claude Code documentation · GitHub Copilot features.

🛠️

Skill - Capability Extension

Capability Enhancement Layer

Skill is a folder of instructions, scripts, and resources that an agent loads on demand for a specialized task. The SKILL.md format is published rather than tied to one product, and Claude Code is one host that loads them. Through Skills, you can: define common commands, encapsulate complex workflows, add domain knowledge.

Skill Types

  • Personal Skills: stored in ~/.claude/skills/ for reuse across projects
  • Project Skills: stored in .claude/skills/ and shared with the repository
  • Plugin Skills: supplied by installed plugins
  • Bundled capabilities: version-dependent; use /help for the current command set

Definition example

---
name: component-docs
description: Generate documentation for Vue components. Use when the user asks to document a component or component library.
---

Component documentation

  1. Inspect component props, emits, slots, and dependencies.
  2. Generate a usage example.
  3. Document accessibility and edge cases.
  4. Link to related components.

Path: ~/.claude/skills/component-docs/SKILL.md

How to use

  1. Create a folder containing a complete SKILL.md under ~/.claude/skills/<name>/ or .claude/skills/<name>/
  2. Include the YAML name and description fields shown above
  3. Describe the task or mention the Skill by name; do not assume an undocumented built-in command exists
  4. Run /help and consult the current documentation for version-specific commands

Built-in commands

Claude Code includes bundled capabilities whose names can change by version. Run /help or consult the current command reference. Personal, project, and plugin Skills may also expose /skill-name commands.

🧩

Harness - Agent Scaffold

Runtime Host Layer

Harness is an editorial term here for the host runtime around a model or agent. A harness may combine system instructions, tool loops, session state, memory, permissions, and integrations, but products draw this boundary differently and do not require every component shown on this page.

Core capabilities

  • Assembles system prompt and tool loop
  • Maintains session context and long-term memory
  • Loads and schedules Skills and MCP servers
  • Provides permissions, sandbox, and logs
  • Hosts across form factors (CLI, IDE plugin, daemon, serverless)

Anatomy of a Harness

Anatomy of a minimal Harness (Claude Code as example)

  1. system prompt → CLAUDE.md / repo briefing
  2. tool loop → Read/Edit/Bash/Grep (built-in tool set)
  3. MCP clients → external servers via mcpServers config
  4. skills → ~/.claude/skills/*.md (loaded on demand)
  5. runtime → terminal REPL / VS Code plugin / gateway daemon

Other Harness implementations:

  • Codex CLI (openai/codex) — terminal Harness written in Rust
  • OpenClaw — cross-platform multi-channel gateway Harness
  • Hermes Agent — Harness with a built-in learning loop
  • Cursor Agent — IDE-embedded Harness

How the Four Fit Together

MCP + Agent

MCP + Agent: Agent uses MCP protocol to call external tools. For example: when Agent needs to read/write files, it completes via MCP filesystem server.

Agent + Skill

Agent + Skill: Skills are Agent’s "skill packs". When user invokes a specific Skill, Agent uses corresponding prompt templates and workflows.

Skill + MCP

Skill + MCP: Skills can encapsulate complex MCP calls. For example: a "Deploy Skill" might call MCP’s Git + Docker + CLI tools.

Harness + the three

Harness + the three: The Harness is the host that wires MCP/Agent/Skill together. Editing a Harness config (e.g. claudedesktopconfig.json) is like rewiring the host; writing a new Skill is like plugging a new tool into the host. Claude Code, Codex CLI, and Cursor Agent are all instances of this "host + three-piece set" pattern.

MCP is the underlying protocol, enabling Agent to communicate with the external world

Agent is the execution entity, planning and executing tasks based on user needs

Skill is the capability extension, making specific tasks more efficient and professional

Harness is the runtime host that integrates the three into a working agent

These concepts often interact, but they are not a mandatory stack and do not form a strict dependency hierarchy. Product boundaries and implementations vary.