Agent Skills Joins the Agentic AI Foundation: What It Means for Your SKILL.md Files

On October 22, Anthropic donated Agent Skills to the Agentic AI Foundation (AAIF), the Linux Foundation group that already hosts the Model Context Protocol. Agent Skills is the format behind SKILL.md files, and Anthropic says more than 70 agent platforms have integrated it, including ChatGPT, Cursor, GitHub Copilot and VS Code.

It didn't arrive alone. AAIF announced four new projects the same day: Agent Skills from Anthropic, Open Responses from OpenAI, OpenEnv from Hugging Face and OpenSandbox from Alibaba. That takes the foundation from three projects at its December 2025 launch to ten.

I keep a folder of skills for my agents, starting with the one that tells them how this blog should sound. So the question for me isn't who gets the logo. It's whether the folder of skills I'm building today will still work next year, in whatever tool I'm using then.

A skill is a folder with a SKILL.md file in it. The file starts with YAML frontmatter that needs two fields, a name and a description, followed by plain Markdown instructions. The folder can also carry scripts, reference docs and templates. Agents load only the name and description up front, then read the full file when a task matches. That's why you can keep dozens of skills around without filling the context window.

Anthropic is handing over the Agent Skills name and logo, the GitHub organization and the agentskills.io domain. Engineers from Anthropic, Google, OpenAI and other companies will maintain the standard as individuals, with David Soria Parra and Mahesh Murag as lead maintainers. You don't need to join AAIF to use the standard or contribute to it.

Anthropic's own numbers: about a million skills published and nearly 280 million installs. That's a lot of folders depending on a format nobody formally owned.

This is the part I like. When one vendor controls a format, every skill you write is a small bet on that vendor. Under a neutral foundation, a SKILL.md I write for one agent is meant to load the same way in the next one.

In practice, that already mostly works. My voice guide for this blog is a skill. It's a name, a one-paragraph description of when to use it, and a page of rules about contractions, structure and what never to invent. Nothing in it is tied to one product, and that's on purpose.

For small teams, the effect is bigger than it looks. The process knowledge that used to live in one senior dev's head, like how you cut a release or which files never get touched, can now live in a folder any agent can read. Now that a foundation looks after the format, that folder is worth writing well.

Anthropic says it has proposed a starting roadmap for the project: versioned releases, a formal proposal process, and security guidance for people who write and install skills. It's a proposal, not a shipped spec yet.

Versioned releases matter more than they sound. Today the spec has no dedicated version field for a skill. Its own example tucks a version string under the optional metadata map. When the format itself starts shipping numbered releases, the tools can tell you which version of the spec a skill was written against, and that's how "it worked in my editor" bugs get found before they ship.

A formal proposal process matters too. Changes go through review in public instead of landing in one company's changelog. If you've lived through an API that quietly changed under you, you know why that's worth having.

This is where I'd slow down. A skill can bundle scripts, and an agent may run them with whatever permissions the agent has. The spec even has an experimental allowed-tools field that pre-approves tools a skill can use. A million published skills is a supply chain, and it deserves the same care as one.

I treat a third-party skill the way I treat a new Composer package. Read the SKILL.md. Read every script. Pin it to a specific commit instead of tracking a branch. Keep a copy in the repo so it can't change under you. I wrote up the dependency side of this in my Composer supply chain attack checklist, and most of it applies here as written.

The security guidance on the roadmap should help. Until it lands, the review is on you.

Audit what you have. List every skill your agents load, where it came from, and whether anyone has read its scripts.

Validate against the spec. The name has to be lowercase with hyphens and match the folder name. The description should say what the skill does and when to use it. The spec points to a skills-ref validate command that checks the frontmatter.

Write for any agent. Keep product-specific notes in the optional compatibility field, not scattered through the instructions.

Watch the repo. Proposals and releases will show up on GitHub and the project's Discord first.

It's a roadmap, not a release. Versioning and security guidance are proposed. Nothing ships today except the move itself.

Portability isn't the same as identical behavior. Each agent decides how it discovers skills, runs scripts and handles experimental fields like allowed-tools.

The other three projects are earlier for most of us. Open Responses, a shared API format based on OpenAI's Responses API, matters if you switch model providers. OpenEnv and OpenSandbox are for training environments and sandboxed execution. They're worth watching, but they're a later problem for most small shops.

None of that is a reason to wait. It's a reason to keep your skills clean so they're easy to move.

I'm keeping my skills plain: Markdown, small scripts, nothing that only works in one product. Agents do more of the work every month, but how the work should be done is still my call, and skills are where I write that down. My current setup is in my AI coding setup for October 2026, and how the agents divide the work is in Cursor, Grok, and the other agents.

If you're a small business that wants agents doing real work in your own systems, with skills you own and can read, that's work I take on. Get a free quote and tell me what you're working with.

A format nobody owns is a format everybody can build on. Write your skills like they'll outlive the tool.

What is Agent Skills?

Agent Skills is an open format for giving AI agents specialized knowledge and workflows. A skill is a folder with a SKILL.md file that has name and description frontmatter and Markdown instructions, plus optional scripts, references and assets.

Who owns Agent Skills now?

As of October 22, 2026, it's a project of the Agentic AI Foundation, part of the Linux Foundation. Anthropic donated the name, logo, GitHub organization and agentskills.io domain. Maintainers from several companies serve as individuals.

Which tools support SKILL.md files?

Anthropic says more than 70 agent platforms have integrated Agent Skills, including ChatGPT, Cursor, GitHub Copilot and VS Code.

Is it safe to install third-party agent skills?

Treat them like any other dependency. Skills can include scripts your agent may run, so read the SKILL.md and every script, pin a specific commit, and keep a copy in your repo. Security guidance is on the project's proposed roadmap but hasn't shipped yet.

What else joined the Agentic AI Foundation?

On the same day, OpenAI's Open Responses, Hugging Face's OpenEnv and Alibaba's OpenSandbox joined. They sit alongside MCP, A2A, AGENTS.md, goose, agentgateway and Agent Router, for ten projects in total.

• Anthropic, "Donating Agent Skills to the Agentic AI Foundation"
• Agentic AI Foundation via PR Newswire, "Agentic AI Foundation Announces Four New Projects: Agent Skills, Open Responses, OpenEnv, and OpenSandbox"
• Agent Skills, "Specification"
• Agent Skills on GitHub, agentskills repository
• The New Stack, "OpenAI donates Open Responses, its spec for a common LLM API, to the Agentic AI Foundation"