Agent Skills is now a Linux Foundation standard

Title card reading Agent Skills goes vendor neutral, with a gold-outlined skill folder of glowing cream text bars releasing a single gold thread that forks into three differently shaped terminal windows.

On October 22, Anthropic donated Agent Skills to the Agentic AI Foundation, the Linux Foundation fund that already stewards MCP. If you ship agent skills to production, the question is what this changes for the folders you maintain. The donation moves the name, the logo, the GitHub organization and the agentskills.io domain to neutral governance; the layer that locks you in, the harness that loads and polices a skill, stays with each vendor. This post covers what transferred and what did not, what the spec actually standardizes, and the seams we found after a year of running skills in our own publishing pipeline.

Anthropic gave away the identity, not the runtime

The announcement came at AGNTCon + MCPCon North America in San Jose, where the Linux Foundation named four new projects joining the Agentic AI Foundation (AAIF), which brings the foundation to 10 hosted projects in its first year, up from three at launch in December 2025.

Project	Donor	What it is
Agent Skills	Anthropic	An open format for packaging instructions, scripts and resources that agents load on demand
Open Responses	OpenAI	A specification for multi-provider LLM interfaces, based on the OpenAI Responses API
OpenEnv	Hugging Face	A framework and community hub for interoperable RL environments
OpenSandbox	Alibaba	A sandbox platform with unified APIs and Docker and Kubernetes runtimes

Read Anthropic’s own post for the precise scope of the transfer: the Agent Skills name and logo, the GitHub organization, and the agentskills.io domain. The code was already open. What changes hands is who decides what the standard becomes: engineers from Anthropic, Google, OpenAI and other companies will maintain it as individuals, with David Soria Parra and Mahesh Murag as lead maintainers, and the proposed starting roadmap covers versioned releases, a formal proposal process, and security guidance for people who write and install skills. The part that matters for your dependency graph is one sentence: “You can continue to use the standard or contribute to it without joining the AAIF.”

A skill is a folder, which is why it spread

The Linux Foundation release carries the cleanest definition of the format: “Skills package instructions, scripts and resources in a reusable manner that agents can load on demand, making specialized know-how portable across agent products and platforms.” Concretely, the specification says a skill is a directory with one required file, SKILL.md, holding YAML frontmatter and Markdown instructions. The frontmatter needs a name (64 characters at most, lowercase letters, numbers and hyphens, matching the directory) and a description of up to 1,024 characters; scripts/, references/ and assets/ directories are optional.

---
name: release-notes
description: Drafts release notes from merged pull requests.
  Use when a release is tagged or the user asks for notes.
---
# Release notes

1. Collect merged PRs since the last tag.
2. Group by area, lead with user-facing changes.
...

The design bet is progressive disclosure: an agent preloads only each skill’s name and description at about 100 tokens, reads the full SKILL.md when a task calls for it (the spec recommends staying under 5,000 tokens), and opens bundled references only as needed. That is context engineering applied to packaging, and it is why an agent can hold a large skill library without burning its window. Simon Willison called it on launch day in October 2025: “Claude Skills are awesome, maybe a bigger deal than MCP”, precisely because a skill is mostly Markdown plus optional scripts. Our own read is that a format this simple makes a loader an afternoon of work for any harness team, and the adoption curve a year later backs that up. Anthropic counts more than 70 agent platforms with Agent Skills support since the standard was published in December 2025, and reports: “So far, 1 million skills have been published and nearly 280 million installed.” Both figures are Anthropic’s own, from the donation post; the foundation publishes no adoption numbers of its own yet.

MCP walked the same road ten months earlier

The playbook is familiar because Anthropic already ran it. The AAIF was formed on December 9, 2025, co-founded by Anthropic, Block and OpenAI, with MCP, goose and AGENTS.md as the launch projects. MCP arrived with more than 10,000 published servers, AGENTS.md with adoption in more than 60,000 open source projects. Anthropic’s MCP donation post gave the reasoning in plain terms: foundational technologies should stay neutral, open and community-driven rather than belong to one vendor.

The pattern held: competitors integrate a format faster once the name on the box is not a rival’s. ChatGPT, Cursor, GitHub Copilot and VS Code all integrated Agent Skills while Anthropic still held the trademark, and OpenAI and Microsoft, the companies behind three of those four, sit as platinum members in the foundation that now governs it, alongside the A2A protocol and MCP. It is no coincidence that David Soria Parra, who co-created MCP, is one of the two lead maintainers here. For a builder, the practical consequence is that writing to the skills format is no longer a bet on Anthropic’s roadmap; it is a bet on a spec that OpenAI, Google and Anthropic engineers maintain together, which is a materially safer bet.

Portability is real, but only at the format layer

The client showcase now spans coding agents (Claude Code, Cursor, Gemini CLI, OpenHands, Goose), IDEs and frameworks (VS Code, Spring AI) and data platforms (Snowflake Cortex Code). The same folder loads in all of them, which does for your know-how what model portability does for your application: your retrieval conventions, your release checklist, your brand rules travel as plain files instead of vendor configuration.

Look at what the spec deliberately leaves out, though. There is a free-text compatibility field for environment requirements and an allowed-tools field the spec itself marks experimental. The standard governs the artifact; the runtime belongs to whoever runs the loop. Nothing in it says when an agent discovers a skill, how the metadata is injected, which model reads it, what executes its scripts, or what the blast radius of those scripts is.

The harness is still the layer that locks you in

All of those undefined behaviors belong to the agent harness, and they are exactly where switching costs live. We made the broader argument in Harness engineering: the model is not the product; the donation sharpens it. When a skill runs its bundled script, one platform executes it in sandboxed code execution with network policy, another shells out on the host, a third asks a human first. When two skills match a task, each harness breaks the tie its own way. Move harnesses and your skills come with you, but your approval gates, sandbox policy and tool wiring get rebuilt, the point we measured when Anthropic priced its hosted harness in Claude Managed Agents: the harness is now a service. Vendor lock-in did not disappear on October 22; it moved down a layer, from the file format to the loop that runs it.

The trap: a skill bundles scripts your agent will run, and the spec’s security guidance is still a roadmap item, so until it ships, treat a third-party skill like an unreviewed dependency: read its scripts before installing, and give the agent that loads it the least tool access that still does the job.

The donation moves the top two layers to neutral ground; the runtime layer, where lock-in lives, was never Anthropic's to donate.

Shipping skills in production showed us where the seams are

Our content production runs on skills; the recipe that produced the post you are reading is one. Its manifest is 481 lines, deliberately under the spec’s guidance to keep SKILL.md “under 500 lines. Move detailed reference material to separate files.” The depth sits in six reference files totaling 1,283 lines (voice rules, verification gates, image recipes) plus two HTML templates, and a scheduled agent loads it unattended six days a week. Anthropic’s engineering team describes the authoring mindset as “Building a skill for an agent is like putting together an onboarding guide for a new hire,” and we would add: write it for the least capable harness that will ever load it.

Because the seams we hit were never in the format. The same SKILL.md that rendered post images on a laptop failed in a cloud runner whose headless browser could not reach Google Fonts, so the skill now inlines the site’s own font files before rendering. The instructions ported; the runtime had to be earned twice. That experience is why we read the donation the way we do: the format going neutral is worth having, and it settles none of the questions that cost us debugging days.

What to change in your skill library this quarter

Three moves follow directly from the governance change. First, adopt the standard layout even for internal-only skills; it costs nothing, and it keeps every option open across the platforms that read it, including the launch-day Claude surfaces and the 70-plus platforms since. Second, stop forking skills per harness: keep one skill, push runtime differences into named steps, and state environment requirements in the compatibility field rather than in tribal knowledge. Third, expect the spec to start versioning. Today it is effectively a living document; the proposed process adds versioned releases, which means future changes will be visible and pinnable, and your loader should record which revision a skill was written against.

The takeaway

Anthropic donating Agent Skills to the Agentic AI Foundation makes the format a safe long-term target: the name, the GitHub organization and the domain now sit with a neutral body, maintainers from three frontier labs carry the spec, and a million published skills say the folder-plus-manifest shape works. What the donation cannot standardize is the harness, where discovery, script execution, sandboxing and approvals still differ per vendor and still carry the switching costs. Write your skills to the open spec, keep the know-how in portable files, and budget your real migration effort for the runtime layer. If you are starting a library, our walkthrough of agent skills for LangChain work shows the shape on a concrete stack.