---
title: "Skills vs MCP? Wrong Question"
description: "With agent frameworks adding Skills support, some are asking if MCP is still needed. Short answer: yes. Here’s why in JS."
url: "https://h3manth.com/scribe/skills-and-mcp-better-together/"
canonical_url: "https://h3manth.com/scribe/skills-and-mcp-better-together/"
markdown_url: "https://h3manth.com/scribe/blog/skills-and-mcp-better-together.md"
publishDate: "2025-12-21T05:30:00.000Z"
author: "Hemanth HM"
category: "ai"
tags: ["ai","agents","mcp","tools","architecture"]
word_count: 952
reading_time_minutes: 5
x_markdown_tokens: 1794
content_signal: "ai-train=yes, search=yes, ai-input=yes"
---

# Skills vs MCP? Wrong Question

> With agent frameworks adding Skills support, some are asking if MCP is still needed. Short answer: yes. Here’s why in JS.

With agent frameworks now supporting Skills, a question keeps coming up: "Does this replace MCP?"

Short answer: **No.**

Skills and MCP are teammates, not competitors. Anthropic designed them to work together. Skills provide the expertise, MCP provides the access. Here's why you need both.

## The Problem I Was Trying to Solve

Before Skills, my agents were slow. Really slow.

Why? Because I was loading everything upfront:

```python
# The old way (still works, but ugh)
agent = Agent("assistant", tools=[
    pdf_tool_1, pdf_tool_2, pdf_tool_3,
    email_tool_1, email_tool_2,
    database_tool_1, database_tool_2,
    # ... 100 more tools 😱
])
```

Every time I started an agent, it had to load all 100 tools into the context window. Even if I was just processing a single PDF. Slow startup, bloated context, split attention.

## My First Solution: Tool Search

Before Skills, I solved this with **deferred tools**. Instead of loading everything, the agent discovers tools on-demand:

```python
# Tools are searchable, not loaded immediately
agent = Agent("payments").with_tools(defer=[
    charge_card, send_receipt, refund_payment
])

# Agent calls search_tools("charge card") → activates charge_card → executes it
await agent.infer("charge $50 to card_123")
```

This worked. The agent uses a `search_tools` function to find relevant tools when it needs them. But it still had problems: tools were just functions. They didn't carry documentation, examples, or context.

## Enter Skills

Skills take tool search further. They're not just functions. They're packaged expertise:

```python
from agentu import Skill

pdf_skill = Skill(
    name="pdf-processing",
    description="Extract text and tables from PDFs",
    instructions="skills/pdf/SKILL.md",    # How-to guide
    resources={"forms": "skills/pdf/FORMS.md"}  # Reference docs
)

agent = Agent("assistant").with_skills([pdf_skill])
```

**What changed:**
- Faster startup (only load what you use)
- Clean context (no irrelevant tools)
- Portable packages (share skills across projects)
- **Bundled documentation** (instructions + resources load progressively)

## So What's MCP?

MCP (Model Context Protocol) connects your agent to external systems.

It's not about loading tools. It's about accessing live data.

```python
# Connect to GitHub
agent.with_mcp(["github"])

# Now your agent can:
# - List your repos
# - Read actual files
# - Create real issues
# - Post actual comments
```

MCP is how you give your agent access to the outside world.

**What you get:**
- Standardized protocol for all external connections
- Built-in auth & permissions
- Security boundaries

MCP servers can be local or remote. There's a growing ecosystem of hosted MCP servers you can connect to:

```python
# Connect to remote MCP servers
agent.with_mcp([
    "github",                              # Official GitHub MCP
    "postgres",                            # Database access
    "https://mcp.paypal.com/mcp",              # Payments
    "https://mcp.slack.com/mcp"                # Team messaging
])
```

This is something Skills can't do. Skills are local expertise packages. MCP gives you live connections to external services, wherever they're hosted.
## See the Difference?

This is the part people miss:

- **Skills**: Things your agent *knows how to do*
- **MCP**: Things your agent *can access*

Different problems. Different solutions.

## Real Example

Let me show you a concrete case where you need both.
**Task:** Build a code review agent.

**What it needs:**

**1. Code Review Skill**
- Tools for static analysis
- Documentation on best practices
- Example feedback formats

**2. GitHub MCP**
- Access to fetch PR diffs
- Access to read files
- Access to post comments

**Without the Skill?**

Your agent can access GitHub fine. But it doesn't know how to give good feedback.

**Without MCP?**

Your agent knows code review principles. But it can't access the actual PRs.

You need both:

```python
from agentu import Agent, Skill

# The expertise
code_review_skill = Skill(
    name="code_review",
    resources={"guide": "review-guide.md"}
)

# The whole thing
agent = (Agent("assistant")
    .with_skills([code_review_skill])  # Knows how
    .with_mcp(["github"]))              # Can access

# Now it works
review = agent.infer("Review PR #247")
```

The Skill teaches it *how to review code*.

MCP gives it *access to GitHub*.

## Another Real-World Example

**Task:** "Analyze customer churn from our database."

```python
from agentu import Agent, Skill

data_skill = Skill(
    name="data_analysis",
    resources={"guide": "analysis-guide.md"}
)

agent = (Agent("assistant")
    .with_skills([data_skill])      # Expertise
    .with_mcp(["postgres"]))        # Access

analysis = agent.infer("""
    Query customer data from the last 6 months
    and identify churn patterns
""")
```

**What happens:**

1. Agent uses Postgres MCP → queries customer table
2. Agent uses Data Skill → applies statistical analysis
3. Agent uses Data Skill → identifies patterns
4. Agent generates insights

Neither Skills nor MCP could do this alone.

## Why This Confusion Exists

Both involve "tools," which is where people get mixed up.

But they're different kinds of tools:

**Skill tools:** Functions your agent runs locally

```python
# Pure function, no external deps
parse_pdf(file)
```

**MCP tools:** Bridges to external services

```python
# Requires GitHub auth, makes API calls
github/get_pull_request(number)
```

An agent might use a Skill to understand how to query a database, and MCP to actually connect to it.

## How I Use Both in agentu

Here's a real example: a due diligence assistant for evaluating companies.

```python
from agentu import Agent, Skill

# Financial analysis expertise
finance_skill = Skill(
    name="financial_analysis",
    resources={"guide": "finance-guide.md"}
)

agent = (Agent("assistant")
    .with_skills([finance_skill])
    .with_mcp(["postgres", "google-drive"]))

report = agent.infer("""
    Pull Q3 financials from our database,
    compare against the pitch deck in Drive,
    and flag any discrepancies
""")
```

The agent knows *how* to analyze financials (Skill) and can *access* your database and Drive (MCP).

## The Bigger Picture

Skills and MCP solve different problems.

**Skills** = what your agent knows how to do  
**MCP** = what your agent can access

You need both. An agent with Skills but no MCP is smart but isolated. An agent with MCP but no Skills is connected but inefficient.

It's not Skills vs. MCP. It's Skills *and* MCP.

## Try It

Both are in agentu:

```bash
pip install agentu
```

Examples:
- [Skills docs](https://github.com/hemanth/agentu/tree/main/examples/skills)
- [MCP guide](https://github.com/hemanth/agentu#mcp-support)

So stop asking "Skills vs MCP?" Use both.