Skills over MCP is an upcoming extension to the Model Context Protocol that lets servers ship domain knowledge alongside tools — structured instructions that tell the model how to use the server's capabilities effectively.
The motivation is practical: large MCP servers with many tools create a usability problem even after context bloat is solved via progressive discovery. A model may find the right tool but still misuse it — calling tools in the wrong order, missing required setup steps, or failing to compose tools the way the server author intended. Skills over MCP solves this by letting the server declare "here's how you're supposed to use these tools" as a first-class protocol primitive.
What It Enables
- Server-authored usage guidance — the server defines workflows, best practices, and tool composition patterns that travel with the server itself
- Continuous updates — server authors can ship updated skills without relying on plugin registries, client-side config, or manual documentation. The skill lives on the server and updates when the server updates
- Platform independence — any MCP client that supports the extension gets the skills automatically, regardless of whether it's Claude, ChatGPT, VS Code, or a custom agent
Current State
Skills over MCP is announced but not yet in the spec. The MCP team indicated it's coming as an extension mechanism — meaning clients opt into support rather than requiring universal adoption. Some clients will support it (likely web-based and IDE clients first), others won't.
The pattern can be approximated today without formal protocol support. A server can expose a load_skills tool that returns markdown instructions, or include usage guidance in tool descriptions. But these are workarounds — they lack the semantic clarity that a formal primitive provides, and clients can't distinguish "this is a skill" from "this is a tool response."
Relevance to MythOS MCP
MythOS already ships a version of this pattern informally. The get_context tool returns augmentation context — style rules, collaboration values, discovery rules — that functions as domain knowledge for how to interact with the library. Skills over MCP would formalize this: instead of bundling instructions into a tool response, MythOS could declare skills as a protocol-level primitive that clients handle natively.
Potential MythOS skills: memo creation workflows (template discovery → template read → create), knowledge graph navigation (get_context → search → read → get_related), and tag hygiene rules.
This is the extension I'm most interested in for MythOS. The gap between "here are 20 tools" and "here's how to use them well" is where most MCP integration quality breaks down. MythOS has solved this with get_context and augmentation memos, but it's a custom solution — skills over MCP would make it a standard that every server can adopt and every client can understand.
The fact that you can already approximate this today (and MythOS does) is a good sign. It means the formal primitive will codify patterns that are already proven, not invent new ones.