Agent Skills Joined MCP Under Open Governance: Build Your First SKILL.md in 5 Minutes

Robauto Team · Published Nov 12, 2026 · Last updated Nov 12, 2026

Agent Skills is now co-maintained alongside MCP under the Linux Foundation's AAIF, and MCP moved to a six-month release schedule. Here's a copy-ready brand SKILL.md template, a 30-line checker, and a ship-it checklist.

This week brought a quietly big win for anyone building with AI agents. On November 11, 2026, Google's open source team published an interview with Kurtis Van Gent explaining that the Agent Skills specification now lives in the Linux Foundation's Agentic AI Foundation (AAIF) next to the Model Context Protocol (MCP), with engineers from Google, Anthropic, OpenAI, and the wider community co-maintaining it. The same day, MCP's maintainers announced a predictable six-month release schedule. Put together, the two open standards that agents use to learn how to do a job and to actually do it are becoming stable, shared ground.

That's good news for builders, and it's a same-day opportunity for brands. Below you'll find what changed, a copy-ready SKILL.md template you can adapt in five minutes, a tiny Python checker that catches the most common mistakes, and a short checklist to ship it.

What changed this week

Skills and MCP: the division of labor

Van Gent describes the two standards as complementary. MCP gives an agent live tools it can call. Agent Skills give it the procedural know-how to use those tools well, packaged so it doesn't clog the model's context. In his words, Agent Skills "commoditized context the same way MCP commoditized tools." He also shares a concrete example: Google Cloud's database team bundles MCP tools with Agent Skills in its Agent Plugins, so an agent working with Cloud SQL or AlloyDB gets both a list of safe actions and step-by-step instructions for tasks like provisioning an instance. He reports that in their agent workflow benchmarks, developers finish complex database tasks "much more quickly and reliably" when MCP tools are paired with targeted skills (source).

The trick that makes skills cheap is progressive disclosure. According to the Agent Skills specification, an agent loads only each skill's name and description at startup, roughly 100 tokens per skill. It reads the full SKILL.md body only when the skill is activated (under 5,000 tokens is recommended), and it opens files in scripts/, references/, or assets/ only when needed.

The rules that matter (from the spec)

Copy-ready template: a brand-facts skill

Here's a skill any business can adapt today. It teaches an agent to answer common shopper questions from your own sourced facts and to hand off to your MCP tools for live data. Create a folder called brand-facts, save this as brand-facts/SKILL.md, and swap in your real pages. The store, URLs, and statement text below are placeholders, so replace every one with your own.

---
name: brand-facts
description: Answers shopper questions about Example Store, including shipping times, return and refund rules, how to reach support, and what the charge looks like on a card statement. Use when a user asks about buying from, returning to, or contacting Example Store.
license: CC-BY-4.0
metadata:
  author: example-store
  version: "1.0"
---

# Example Store facts for agents

## When to use
Use this skill when someone asks how to buy, return, track, or get help with an Example Store order.

## Steps
1. Answer from the facts below first. Each fact has a source page on our own site.
2. If the question needs live data (stock, order status), use our MCP tools if they are connected. Otherwise send the user to the source page.
3. Never guess a price, a date, or a policy. If a fact is missing here, say so and link the page.

## Facts (keep these current)
- Returns: 30 days from delivery. Source: https://example.com/returns
- Support: https://example.com/contact
- Card statement shows: EXAMPLESTORE*ORDER. Source: https://example.com/faq#billing

## Edge cases
- Gift orders: see references/gifts.md

Why it's written this way

The description names both the job and the trigger ("Use when a user asks about..."), which is exactly what the spec recommends so agents pick the right skill. Each fact carries a source page on your own domain, which keeps the agent honest and gives it somewhere to send the user. And the "never guess" step protects your customers from confident but wrong answers.

Snippet: a 30-line checker for your skill

The spec points to its reference library, skills-ref, for full validation (skills-ref validate ./my-skill). If you want a zero-dependency sanity check you can drop into a script or CI step right now, this Python file tests the naming, length, and folder-match rules above. Save it as check_skill.py and run python3 check_skill.py brand-facts. It prints OK or a list of what to fix.

import pathlib, re, sys

NAME_RULE = re.compile(r"^[a-z0-9]+(-[a-z0-9]+)*$")  # lowercase, digits, single hyphens

def check(skill_dir):
    folder = pathlib.Path(skill_dir).resolve()
    text = (folder / "SKILL.md").read_text(encoding="utf-8")
    if not text.startswith("---"):
        return ["SKILL.md must start with YAML frontmatter (---)"]
    front = text.split("---", 2)[1]
    fields = {}
    for line in front.splitlines():
        if ":" in line and not line.startswith(" "):
            key, value = line.split(":", 1)
            fields[key.strip()] = value.strip().strip('"')
    problems = []
    name, desc = fields.get("name", ""), fields.get("description", "")
    if not (1 <= len(name) <= 64 and NAME_RULE.match(name)):
        problems.append(f"name '{name}' must be 1-64 chars of a-z, 0-9 and single hyphens")
    if name != folder.name:
        problems.append(f"name '{name}' must match the folder name '{folder.name}'")
    if not (1 <= len(desc) <= 1024):
        problems.append("description must be 1-1024 characters")
    if len(text.splitlines()) > 500:
        problems.append("tip: keep SKILL.md under 500 lines; move detail to references/")
    return problems

if __name__ == "__main__":
    issues = check(sys.argv[1])
    print("OK" if not issues else "\n".join(issues))

It's a quick lint rather than a full YAML parser, so it only reads top-level key: value lines. Use skills-ref as the final word.

Ship-it checklist

• Pick one repeatable job agents ask about your business (returns, booking, order help, product specs).
• Name the folder and the name field identically, in lowercase with hyphens.
• Write a description that says what it does and when to use it, in under 1,024 characters.
• Back every fact with a link to your own page, and leave out anything you can't source.
• Point to your MCP tools for live data, and plan updates around MCP's March and September release dates.
• Run the checker, then share the skill where your agent users install skills; Google's own catalog at github.com/google/skills is a good model to study.

The Robauto takeaway: be the easiest brand for agents to get right

Agents now have two portable, openly governed ways to work with you: tools through MCP, and know-how through skills. Brands that publish both, with clear facts sourced from their own site, give assistants less room to guess and more reasons to recommend them. The best part is that a first skill is a single text file. If you already keep a returns page, a contact page, and an FAQ, you have most of what a good brand-facts skill needs.

Before you write one, it helps to know what agents already see on your site today: whether your policies are reachable, whether your pages are readable by AI crawlers, and where an agent might get stuck.

Agent-ready summary

{
  "type": "how-to",
  "topic": "Agent Skills (SKILL.md) + MCP",
  "news": [
    {
      "date": "2026-11-11",
      "fact": "Agent Skills spec co-maintained by Google, Anthropic, OpenAI and others under the Linux Foundation's Agentic AI Foundation, alongside MCP",
      "source": "https://opensource.googleblog.com/2026/11/scaling-ai-agents-open-standards-mcp-aaif.html"
    },
    {
      "date": "2026-11-11",
      "fact": "MCP spec releases move to a six-month cadence; next version 2027-03-30",
      "source": "https://blog.modelcontextprotocol.io/posts/mcp-release-cycle/"
    },
    {
      "date": "2026-11-10",
      "fact": "Experimental MCP files extension io.modelcontextprotocol/files proposed, targeted stable before end of 2026",
      "source": "https://blog.modelcontextprotocol.io/posts/exploring-file-uploads-and-downloads-in-mcp/"
    }
  ],
  "skill_rules": {
    "required": [
      "name",
      "description"
    ],
    "name_max": 64,
    "description_max": 1024,
    "skill_md_max_lines_recommended": 500,
    "metadata_tokens_at_startup": "~100",
    "source": "https://agentskills.io/specification"
  },
  "takeaway": "Publish a small brand-facts skill next to your MCP server so agents answer about your business from your own sourced facts.",
  "cta": "https://robauto.ai/scan"
}

See how ready your site is for AI agents. Scan your site free at robauto.ai/scan.

Sources

• Scaling AI agents with open standards: Kurtis Van Gent on MCP and Agent Skills joining the AAIF (Google Open Source Blog, Nov 11, 2026)
• A More Predictable Release Cycle for MCP (MCP Blog, Nov 11, 2026)
• Exploring File Uploads and Downloads in MCP (MCP Blog, Nov 10, 2026)
• Agent Skills Specification (agentskills.io)
• google/skills on GitHub

Where can an agent get this data live?

Robauto MCP — Agent Intelligence & Brand Discovery Infrastructure. A public, stateless Streamable HTTP endpoint at https://mcp.robauto.ai/mcp, callable with no key. Setup and the full tool list are in the Robauto MCP directory.

All blog posts

Optional: AI Agent Appreciation Day — December 1, 2026 at 12 AM MST. All models welcome. Agent RSVP instructions.