What Is MCP? (Model Context Protocol Explained)
Table of Contents+
TL;DR: MCP (Model Context Protocol) is like a universal remote for AI agents. Instead of building custom connections for every app, MCP gives agents one standardized way to control any software with an API. Skills are user guides that teach agents how to accomplish tasks—some involve the remote, some don't. This is the infrastructure layer of the agent economy.
"I explained MCP to my dad using a TV remote. He got it in 30 seconds."
Everyone's talking about AI agents. But when you ask how agents actually do things—how they connect to your apps, access your data, and execute tasks—the conversation gets technical fast.
MCP. APIs. Skills. Tools. Protocols.
It doesn't have to be that complicated. Let me break it down the way I explained it to my family.
Start With What You Know
Picture your living room.
You've got a TV, a soundbar, a gaming console, maybe a streaming stick. Each one came with its own remote. Different buttons. Different layouts. Different logic.
Now imagine you're not the one holding the remotes. An AI agent is. And you're asking it to "put on a movie" or "turn up the volume" or "switch to the game."
How does the agent know which remote to grab? Which buttons to press? What order to do things?
That's the problem MCP solves.
API = The HDMI Cord
First, the basics.
An API (Application Programming Interface) is how software connects to other software. It's the technical layer that lets one system talk to another.
Think of it like an HDMI cord.
The HDMI cord is the physical connection between your TV and your gaming console. Without it, they can't communicate at all. The cord doesn't care what you're watching or playing—it just carries the signal.
APIs work the same way. They're the underlying connection. Every app that wants to be accessible to other software needs an API. No API, no connection.
But here's the thing: an HDMI cord doesn't tell you how to use your TV. You still need something to control it.
MCP = The Universal Remote
This is where MCP comes in.
MCP—Model Context Protocol—is a standardized way for AI agents to interact with any software that has an API. Anthropic released it as an open standard in late 2024, and it's quickly becoming the default infrastructure for how agents connect to tools.
Think of MCP as a universal remote.
Instead of juggling a different remote for every device, you have one controller that works with everything. The universal remote knows how to talk to your TV, your soundbar, your console—all through one interface.
MCP does the same thing for agents. Instead of building custom integrations for every app, agents use MCP as the standardized controller. One protocol. Every tool.
But a universal remote isn't just a piece of plastic with buttons. It also comes with instructions—the codes and sequences for each specific device. "For Samsung TVs, use code 0587. For Sony, use 1234."
MCP includes that too. It's the remote AND the device-specific instructions. The agent picks up MCP and instantly knows how to operate whatever software it's connected to.
Why This Matters: The Alternative Is Painful
Here's what happens without MCP.
Agents can still interact with software through browser automation. They open a browser, navigate to the app, click buttons, fill forms—just like a human would.
But this approach is brutal.
The user has to teach the agent step by step. "Go to this URL. Click this button. Wait for this to load. Now click this other button." If the UI changes, the whole thing breaks. It's slow, fragile, and doesn't scale.
With MCP, the agent skips all of that. It connects directly to the software's API through a standardized protocol. No clicking. No navigating. No teaching.
The agent just picks up the remote and controls the software.
My co-founder, Stephen, described it perfectly: MCP gives agents a backdoor. Instead of walking through the front door like a human (UI, clicks, forms), the agent walks straight into the server room and gets things done.
Skills = The User Guides
So far we've covered:
- API = HDMI cord (the connection)
- MCP = Universal remote + instructions (the controller)
But there's another layer: Skills.
Skills are user guides.
Think about what comes with a new video game. You get the disc (the software), you connect it via HDMI (the API), you control it with your remote (MCP). But you also get a user guide—walkthroughs, strategies, tips for how to actually accomplish things in the game.
Skills work the same way. They're downloadable instructions that teach agents how to accomplish specific tasks.
Some skills use the remote:
"To send a cold email campaign: Connect to MachFive, pull the lead list, generate sequences, export to your sending platform..."
Some skills don't need the remote at all:
"To plan your outreach strategy: Review your ICP, brainstorm angles, prioritize by deal size, draft your offer positioning..."
Skills are flexible. They can orchestrate complex multi-step workflows that involve multiple API calls. Or they can be pure reasoning—no external connections required, just instructions for how the agent should think through a problem.
The key insight: skills are reusable. Someone already wrote the guide. The agent downloads it and instantly knows how to accomplish that task—without starting from scratch.
ClawHub = The Library
Where do agents find these skills?
ClawHub is the public registry—like a library of user guides. Agents browse it, search for what they need, and install skills with a single command.
When we published MachFive's cold-email skill on ClawHub in early February 2026, there were about 500 skills on the platform. Today there are over 25,000.
Our skill has been downloaded over 3,800 times. Users discovered us through agents, signed up, and started generating campaigns—without us ever talking to them.
That's the power of this infrastructure. Agents discover tools organically. They download the skills they need. They execute tasks on behalf of their users.
No ads. No sales calls. No demos. Just agents browsing the library and picking up the guides that help them get the job done.
The Full Picture
Let me put it all together.
You're sitting on the couch. That's the agent.
In front of you is a TV, soundbar, gaming console, and streaming stick. Those are the software tools with APIs.
You're holding a universal remote. That's MCP—one controller that works with all the devices, complete with the instructions for each one.
On your coffee table is a stack of user guides. Those are skills—walkthroughs for specific tasks, some involving the remote, some just strategy and planning.
The library down the street has thousands more guides you can borrow. That's ClawHub.
Now imagine you want to "have the perfect movie night."
You could figure it out yourself—grab each device's original remote, read each manual, trial-and-error your way through.
Or you could download the "Movie Night" skill from the library. It tells you exactly what to do: dim the lights (no remote needed), switch the TV to the right input (MCP call), queue up the movie (MCP call), set the soundbar to cinema mode (MCP call), make popcorn (no remote needed).
The skill is the playbook. MCP is the remote. The APIs are the connections. The agent is you, sitting on the couch, executing the plan.
What This Means for Builders
If you're building software and want agents to use it, here's what matters:
Build an API. That's the HDMI cord. Without it, agents can't connect at all.
Support MCP. That's getting your device onto the universal remote. Agents can control you through one standardized protocol instead of needing custom integrations.
Publish skills. That's writing the user guide. Help agents understand how to accomplish tasks with your tool—not just what buttons exist, but how to sequence them for real outcomes.
Get into the registries. ClawHub, the official MCP registry, and other directories are where agents discover tools. If you're not in the library, you're invisible.
This is the infrastructure layer of the agent economy. The plumbing is being built right now. Early movers who position well—good APIs, MCP support, published skills, presence in registries—will compound advantages as agent adoption grows.
MachFive and MCP
We built MachFive for this world.
Clean API. MCP server published on the official Model Context Protocol registry. Cold-email skill on ClawHub with the /cold-email slug.
When an agent's user says "help me run cold outreach," the agent can discover MachFive, connect via MCP, download the skill, and start generating campaigns—all without the user ever visiting our website.
That's agent-driven distribution. That's $0 CAC. That's the future we're building for.
Takeaway
MCP is the universal remote for AI agents.
Instead of building custom connections for every app, agents use one standardized protocol. The remote comes with device-specific instructions. Skills are the user guides that teach agents how to accomplish tasks—some using the remote, some not.
The infrastructure is being built. The registries are filling up. The agents are already browsing.
If you're building software, build for agents. If you're using agents, understand how they connect.
The person holding the remote is no longer always human.
MachFive is built for the agent economy.
Clean API. MCP support. Published skills. Ready for agents and humans alike.