November 13, 2026 | Jeremiah Lowin

FastMCP 4.2

License to skill

Skills over MCP is one of the most exciting extensions to the protocol we’ve seen, and FastMCP 4.2 is all about making it easy to use.

I’ve always thought the skills-versus-MCP debate was strange. I’ve written and talked with Tristan Handy about this before: MCP tools expose business logic; skills provide behavioral guidance. Giving an agent new capabilities and helping it use them well are complementary things. Why would we want to choose?

Now we can deliver them together. The same MCP server that exposes a product’s tools can also distribute the skills for working with them. The people who build the software can ship their expertise alongside its capabilities.

Have skills, will travel

The people building a product know which operations belong together, which shortcuts are safe, and which checks should never be skipped. A tool description can explain an individual operation. A skill can explain how to accomplish something with several of them.

Think about a deployment platform. Its MCP server might already let an agent inspect a deployment, read logs, and roll back a release. The team building that platform also knows how to investigate a failed rollout, what to check before reverting, and how to confirm that the recovery worked. They can package that procedure as a skill and serve it alongside the tools.

The next agent connecting to the platform can discover both. The team maintains the guidance at its source, and clients can fetch it when they need it. That makes the team’s operational knowledge something they can ship with the product.

We can give other people’s agents the expertise to use our software. That’s a much more interesting thing to distribute than an API wrapper.

Shipping a skill

We’ve made skills a first-class Python object in FastMCP. You can define a skill entirely in code, without creating a SKILL.md file. Give it a name, a description, and instructions, then add it to your server.

For example, a server with pull-request tools can also teach an agent how your project writes release notes.

from fastmcp import FastMCP, Skill
from fastmcp.skills.provider import SkillCatalogProvider


release_notes = Skill(
    name="release-notes",
    description="Write release notes from merged pull requests.",
    instructions="Group changes by theme. Explain migrations. Link to each PR.",
)


mcp = FastMCP("Project")
mcp.add_provider(SkillCatalogProvider([release_notes]))

That’s a skills server. The instructions could just as easily come from a database or be assembled by your application. Supporting files can be supplied in memory, too. These are software-defined skills, so you can use ordinary Python to build and manage them. Existing skill folders work as well.

Delivery included

We’ve built the client side, too. Enable the Skills extension on a FastMCP client, and list_skills() discovers what’s available. A single read_skill() call retrieves a complete skill, including its supporting files, as the same Python Skill object you use on the server. Your application can inspect it, serve it again, or write it to a directory for an agent that loads skills from disk.

Host support is still early, and we’re partnering with the VS Code team to make sure skills work smoothly with your MCP servers. VS Code just released its Skills over MCP preview. You can use it in VS Code today, and that’s where we recommend starting.

The extension is in Beta, and FastMCP’s support remains experimental. Nate is covering the full how-to on the Prefect blog, and the Skills guide has the server and client examples to get started.

We’ve spent a lot of time making it easy to give agents tools. I’m excited to help give them a few skills, too.

Subscribe