Distributed Skills Over MCP: Playbooks as a Shared Service
Most automation pilots still ship the same shape: one orchestrator, a pile of specialist agents, and a hope that each nested model loop will “do the domain right.” That pattern works for demos. It gets expensive and hard to govern the moment every specialist owns its own reasoning, its own prompt copy, and its own redeploy cycle.
The fresher business move is narrower. Keep the domain services. Publish the playbook — the procedure your operators already trust — as an Agent Skill over MCP. Let the parent agent load that procedure on demand and call typed tools directly. Domain ownership stays distributed. Reasoning moves up. The platform team maintains a source, not a zoo of prompt forks.
That is what SEP-2640 unlocked when it merged as Final on 13 September 2026, and what Microsoft’s Agent Framework team demonstrated a few days later with a side-by-side ski-resort advisor.
The useful split
A tool is a verb your systems can execute. A Skill is the playbook for when and how to use those verbs. MCP is the pipe. Distributed Skills over MCP means the playbook is a shared, versioned service — not a Markdown file copied into every agent deployment.
What Final actually changed
Until mid-September, Agent Skills and MCP solved adjacent problems. Skills gave you a portable SKILL.md directory. MCP gave you a standard way to expose tools and resources. There was no shared contract for remote discovery, integrity, origin, and approval when those playbooks crossed a network trust boundary.
AI Stack Current’s write-up of the Final extension is clear on the status boundary: SEP-2640 is Final, but Skills is an opt-in extension (io.modelcontextprotocol/skills), not a mandatory base-protocol feature. Both peers must advertise and implement it. Finalization is a stable contract; it is not universal deployment.
What the Final shape adds for operators:
skills/listandskills/get— enumerate or resolve skills with metadata and a file manifest, then read files on demand through existingresources/read.- Manifest + digests — each skill entry can carry per-file sizes and SHA-256 digests (or
"dynamic"when bytes are not stable). Listing a skill does not dump every attachment into model context. - Approval bound to the manifest — if files change, prior approval no longer covers the skill. Approving the friendly name
invoice-matchonce is not enough. - Origin as identity — skill identity includes the originating server and URI, not just the short name. Two servers publishing
deploy-productionmust not silently replace each other in a cache. - Skills as data, not authority — digests prove bytes match the advertised manifest. They do not prove the publisher is trustworthy, and they do not grant tool, filesystem, credential, or network permissions. Host policy still owns execution.
That last line is the governance win. Remote playbooks stop looking like “magic trusted packages” and start looking like untrusted instructional content with a verifiable envelope.
Specialist agents versus distributed skills
Tommaso Stocchi’s Microsoft Agent Framework post (16 September 2026) asks the question ops teams should put on the whiteboard:
Does every specialist need its own model execution, or does the parent mostly need the specialist’s instructions and access to its operations?
His ski-resort demo keeps both architectures on the same application. One path uses Agent-to-Agent (A2A) specialists for weather, safety, ski coaching, and lift traffic. The other path publishes each domain as a description, a SKILL.md, and typed MCP tools. The advisor loads instructions when needed and invokes operations directly. Domain services stay remote. Nested specialist model loops disappear for the migrated domains.
Stocchi’s three-pair illustration is careful about what it proves and what it does not. For the same prompt (“considering weather and waiting time, where should i start?”):
- The A2A path used six or seven model calls per request across advisor and specialists.
- The skills path used three model calls, all in the advisor.
- Mean client elapsed time in those reused-process runs was about 15.48 s (A2A) versus 6.35 s (skills) — roughly 60% faster in that demo.
- Token totals went the other way: about 13,533 observed tokens for skills versus 11,134 for A2A across three runs (~22% more). Fewer calls did not mean less cumulative context.
He labels this a three-pair illustration, not a controlled production benchmark: processes were reused, cache hits varied, live telemetry changed, and the two paths did not always perform identical work. Treat those figures as his measured demo, not a universal ROI table. The structural lesson is still useful: when a competence is a procedure plus typed operations, paying for another reasoner is optional.
Microsoft’s companion .NET post frames the enterprise value in one sentence: author once, serve everywhere — a platform team publishes skills to an MCP server; agents discover them on demand without redeploying every consumer.
When to keep the specialist agent
Stocchi’s rule of thumb: keep A2A (or any autonomous agent loop) when the specialist needs its own model, private context, a substantial workflow, or an independent lifecycle — research agents, long-running jobs, specialized models. Convert to a distributed skill when the competence is bounded: a procedure plus typed operations the parent can run. The same application can use both.
Why business automation cares
Copying SKILL.md into every bot repo is how playbooks rot. Finance’s invoice rules live in three assistants with three slightly different versions. Support’s billing-vs-product table is updated in Slack, not in the skill the agent loads. Security cannot answer which instruction bytes were approved last Tuesday.
A Skills-over-MCP rail changes the operating model:
- One source of truth for procedures. Ops and domain owners version the playbook where it is published. Consumers pull the current approved manifest.
- Progressive disclosure at enterprise scale. Advertise short metadata; load the body only when the task matches; fetch supporting files only when needed. That is the same progressive-disclosure idea builders debate on Hacker News around MCP context — now with a remote delivery contract.
- Clearer blast radius. Approving a skill is not the same as authorizing
post_invoice. Keep those decisions separate, the way SEP-2640 requires. - Fewer nested bills. Every specialist loop is another planning tax. Stocchi’s demo is one data point that collapsing unnecessary reasoners can cut model calls even when total tokens do not shrink.
This complements — it does not replace — the connector and authorization work. An HN thread on enterprise MCP gateways still lands on the missing middleware layer: OAuth refresh, per-user schema mapping, rate limits, and audit. A recent DEV Community enterprise MCP guide (30 September 2026) puts a gateway between agents and servers for the same reasons: authN/Z, logging, and policy in one place. Distributed skills sit above that pipe. They answer “which playbook,” not “which identity may call which verb.”
Trust is not a checkbox labeled “skill approved”
Remote skills raise a failure mode local folders hide: name collision and silent replacement.
SEP-2640’s Final design (as summarized by AI Stack Current, and as merged in PR #2640) treats origin + URI as identity, binds approval to digests, and requires a new approval when the manifest changes. Cross-server resource reads need explicit consent naming both servers. Nested skills do not auto-activate.
On X, builders are already pointing at the policy bottleneck. Aniket Tapre put it bluntly on 2 October 2026 (Europe/Madrid): a million agent skills is impressive; the bottleneck becomes which skills an agent may load, what data each can touch, and how you revoke a skill the moment it misbehaves. Josh Builds covered Figma’s remote MCP allowlist the day before — client allow-lists are another reminder that “speaks MCP” is not the same as “trusted in your estate.”
Do not collapse the trust stages
Server identity → Skills capability negotiation → metadata and manifest → user/host approval → verified on-demand reads → model context → separate tool and code authorization. A verified skill can still contain bad instructions. An approved playbook still does not imply permission to execute every tool it mentions.
Also watch wire-shape drift. Stocchi notes his demo’s skill://index.json path followed a historical Draft of SEP-2640 checked on 10 September 2026, before Final’s skills/list / skills/get shape landed. AI Stack Current makes the same warning: older drafts can look like “Skills over MCP” while speaking a different contract. Pin clients and servers to the Final extension before you call the rail production-ready.
What to ship this week
You do not need a skills marketplace or a full multi-agent rewrite.
- Pick one bounded, read-oriented domain with a system of record — invoice match checks, CRM follow-up rules, support billing triage, vendor credit lookup. Prefer a workflow where irreversible writes can stay gated.
- Write one operator-owned
SKILL.md. Required inputs, ordered steps, explicit “no LLM” versus “LLM decision point,” definition of done. Version it like other enterprise software. - Expose a small MCP tool surface named for outcomes —
check_invoice_match,log_crm_activity,fetch_credit_report— not every ERP endpoint. Keep business rules and authorization in code; the skill guides selection, it does not replace server-side checks. - Publish the skill from one MCP server your agents already connect through (ideally behind a gateway with audit). Prefer Final SEP-2640 discovery (
skills/list/skills/get) over a one-off draft index. - Bind approval to the manifest. Record origin server + URI + digests. Re-approve on change. Keep skill approval separate from tool authorization for send, post, pay, delete, and access changes.
- Compare against the old path before you cut over. Stocchi’s advice: keep the previous specialist path available; score routing, data correctness, and structured results — not demo latency alone.
If the competence needs private context, a specialized model, or a long-running lifecycle, leave it as an agent. Distributed skills are for playbooks you want to maintain once and consume many times.
Want help turning one operator playbook into a Skills-over-MCP publication with a small tool surface and an approval gate — not another specialist-agent pilot? Talk to us.
Sources
- SEP-2640: Skills Extension — merged Final PR (13 September 2026)
- MCP finalizes Skills extension for portable Agent Skills discovery and delivery — AI Stack Current (13 September 2026)
- From Specialist Agents to Distributed Skills over MCP — Tommaso Stocchi, Microsoft Agent Framework (16 September 2026)
- Discover Agent Skills from MCP servers in .NET — Microsoft Agent Framework
- MCP Won't Solve Enterprise AI Integration (We're Missing a Layer) — Hacker News
- Stateless MCP has recaptured my interest — Hacker News (progressive disclosure / skills vs tools context discussion)
- Building an Enterprise AI Agent with MCP: Architecture and best practices — DEV Community (30 September 2026)
- Aniket Tapre on X — skill load policy and revocation (2 October 2026)
- Josh Builds on X — Figma MCP client allowlist (1 October 2026)
