# Agent Skills joins the Agentic AI Foundation: what the open standard changes, and what a skill still leaves behind > Source: > Published: 2026-10-23 09:43:01+00:00 # Agent Skills joins the Agentic AI Foundation: what the open standard changes, and what a skill still leaves behind Agent Skills is an open format in which a skill is a folder with a `SKILL.md` file that teaches an agent one task, plus any scripts or reference files it needs. On 22 October 2026 Anthropic donated the standard to the Agentic AI Foundation (AAIF) under the Linux Foundation, one of four projects that took the foundation to 10 in its first year. The format did not change that day: the spec still has six front matter fields, no version number and no tagged release. ## What is the Agentic AI Foundation, and what does it now own? The Agentic AI Foundation is a directed fund under the Linux Foundation that Anthropic, Block and OpenAI co-founded in December 2025 with three projects: MCP, [goose](https://stackness.dev/tools/goose) and [AGENTS.md](https://stackness.dev/tools/agents-md). Its governing board handles budget and new projects, while each project keeps "full autonomy over their technical direction" ([MCP blog](https://blog.modelcontextprotocol.io/posts/2025-12-09-mcp-joins-agentic-ai-foundation/)). Its members page listed 287 organizations on 23 October 2026, eight of them Platinum. Anthropic's [announcement](https://www.anthropic.com/news/donating-agent-skills-to-the-agentic-ai-foundation) hands 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 it "as individuals", led by David Soria Parra and Mahesh Murag, and AAIF says a multi-company Technical Steering Committee will guide it. The spec stays under Apache 2.0 for code and CC BY 4.0 for docs. The [Linux Foundation release](https://www.linuxfoundation.org/press/agentic-ai-foundation-announces-four-new-projects-agent-skills-open-responses-openenv-and-opensandbox) added three more projects the same day: Open Responses from OpenAI, OpenEnv from Hugging Face and OpenSandbox from Alibaba. Anthropic says "more than 70 agent platforms" have integrated the standard, and that "1 million skills have been published and nearly 280 million installed." The showcase at [agentskills.io/clients](https://agentskills.io/clients) names 46 products. The install counts come from Vercel's [skills.sh](https://stackness.dev/tools/skills-sh) registry, whose [own report](https://vercel.com/blog/state-of-agent-skills) says they "do not represent unique people or necessarily independent choices." ## A SKILL.md carries six fields and a folder A skill under the [Agent Skills specification](https://agentskills.io/specification) is a directory whose `SKILL.md` starts with YAML front matter. Two fields are required: `name`, up to 64 lowercase characters matching the folder name, and `description`, up to 1,024 characters saying what the skill does and when to use it. Four are optional: `license`, `compatibility`, `metadata` and the experimental `allowed-tools`. ``` --- name: pdf-processing description: Extract PDF text, fill forms, merge files. Use when handling PDFs. license: Apache-2.0 metadata: author: example-org version: "1.0" --- ``` The folder may hold `scripts/`, `references/` and `assets/`, which the spec calls recommendations. Loading happens in three steps. An agent reads every skill's name and description at startup, about 100 tokens each, loads the body (under 5,000 tokens recommended) when a task matches, and opens bundled files only when the body points to them. The reference validator, `skills-ref validate ./my-skill`, is marked "for demonstration purposes only." The spec says nothing about where skills live. The [client implementation guide](https://agentskills.io/client-implementation/adding-skills-support) recommends scanning `.agents/skills/` so that "skills installed by other compliant clients are automatically visible to yours, and vice versa." That folder is a convention, not part of the standard. ## Which coding agents load a SKILL.md today? All nine coding agents I checked on 23 October 2026 load a `SKILL.md` from a project folder, and all nine read the name, description and body. They differ on the folder and on the fields past the spec. [Claude Code](https://stackness.dev/tools/claude-code) is the only one whose docs never mention `.agents/skills/`, and the only one that reads hooks from a skill. | Agent | Project folders | Reads `.agents/skills/` | Extra fields or files it honours | |---|---|---|---| | Claude Code | `.claude/skills/` | No | `hooks` ,`model` ,`effort` ,`context: fork` ,`disable-model-invocation` ,`paths` ,`allowed-tools` and more | | [Codex](https://stackness.dev/tools/codex-cli) | `.agents/skills/` | Yes | A separate `agents/openai.yaml` for invocation policy and MCP dependencies | | [GitHub Copilot](https://stackness.dev/tools/github-copilot) CLI and cloud agent | `.github/skills/` ,`.claude/skills/` ,`.agents/skills/` | Yes | `allowed-tools` ,`license` | | [VS Code](https://stackness.dev/tools/visual-studio-code) agent mode | `.github/skills/` ,`.claude/skills/` ,`.agents/skills/` | Yes | `disable-model-invocation` ,`user-invocable` ,`argument-hint` ,`context: fork` | | [Cursor](https://stackness.dev/tools/cursor) | `.agents/skills/` ,`.cursor/skills/` , plus`.claude/skills/` and`.codex/skills/` | Yes | `disable-model-invocation` ,`paths` ,`metadata` | | [Gemini CLI](https://stackness.dev/tools/gemini-cli) | `.gemini/skills/` ,`.agents/skills/` | Yes, and it wins over `.gemini/` | None; asks for consent on every activation | | [OpenCode](https://stackness.dev/tools/opencode) | `.opencode/skills/` ,`.claude/skills/` ,`.agents/skills/` | Yes | `license` ,`compatibility` , its own`metadata` keys | | goose | `.agents/skills/` , plus`.claude/skills/` | Yes | None documented | | [Amp](https://stackness.dev/tools/amp) | `.agents/skills/` , then`.claude/skills/` | Yes | `mcpServers` or a sibling`mcp.json` | Sources: each agent's skills docs, read 23 October 2026: [Claude Code](https://code.claude.com/docs/en/skills), [Codex](https://developers.openai.com/codex/skills), [GitHub Copilot](https://docs.github.com/en/copilot/concepts/agents/about-agent-skills), [VS Code](https://code.visualstudio.com/docs/copilot/customization/agent-skills), [Cursor](https://cursor.com/docs/context/skills), [Gemini CLI](https://geminicli.com/docs/cli/skills/), [OpenCode](https://opencode.ai/docs/skills/), [goose](https://goose-docs.ai/docs/guides/context-engineering/using-skills/), [Amp](https://ampcode.com/docs/markdown/customize/skills). Where a doc is silent on a field, the table lists nothing; I did not test how each agent treats a field its docs leave out. Turning off automatic invocation is written three ways: front matter in Claude Code, VS Code and Cursor, `policy.allow_implicit_invocation: false` in Codex's `openai.yaml`, and an `opencode/autoinvoke` metadata key in OpenCode. Gemini CLI asks for consent at every activation instead. Only Claude Code and Copilot document honouring `allowed-tools`. Claude Code accepts `license`, `compatibility` and `metadata` but "doesn't act on" them. ## Hooks and MCP wiring stay behind when a skill moves A skill moved between agents keeps its folder, its body, its name and description, and its bundled files. It loses anything an agent added on top. A `hooks` key in front matter runs only in Claude Code, which registers those hooks "when the skill is invoked". MCP servers are not part of the spec: Amp lets a skill declare them, Codex puts them in `openai.yaml`, and Claude Code keeps them in its own config. Body text does not port cleanly either. Claude Code substitutes `$ARGUMENTS`, `${CLAUDE_SKILL_DIR}` and other variables before the model reads a skill; none of the other eight agents' docs mention substituting them. Packaging is half shared: [Agent Plugins](https://agent-plugins.org/) 1.0.0, a separate vendor-neutral standard whose steering committee includes Amazon, Cursor, Microsoft, OpenAI and Vercel, defines one plugin format for skills and MCP servers, while hooks, subagents and commands inside a plugin stay client-specific. The [Claude Code mod post](https://stackness.dev/blog/what-is-a-claude-code-mod-and-where-does-it-sit-next-to-plugins-skills-hooks-and-mcp) covers how those layers stack in one agent. ## A skill sits between AGENTS.md and a hook Agent Skills is now one of three AAIF formats a coding agent loads, next to AGENTS.md and MCP, and each holds a different kind of instruction. AGENTS.md holds facts and rules that apply every session. A skill holds a procedure loaded when a task matches. A hook holds a rule that must run every time, outside the model's context, and has no shared standard. | Layer | Loads | Holds | Shared standard | |---|---|---|---| | AGENTS.md | Every session | Facts and always-on rules | Yes, AAIF | | Skill | Name and description at start, body on use | Procedures, reference, scripts | Yes, AAIF | | MCP server | Tool names at start | Live tools and data | Protocol yes, config files per agent | | Hook | On lifecycle events | Rules that must hold | No | | Plugin | At install | A bundle of the above | Skills and MCP servers yes (Agent Plugins, outside AAIF); hooks no | Claude Code's [features overview](https://code.claude.com/docs/en/features-overview) puts the split in one line: "MCP connects Claude to external services. Skills extend what Claude knows, including how to use those services effectively." The [layers post](https://stackness.dev/blog/agents-md-vs-claude-md-vs-skills-which-layer-each-instruction-belongs-in-and-what-to-delete) goes through which instruction goes where. ## MCP's first year at the foundation: one spec release and a formal process The [Model Context Protocol](https://stackness.dev/tools/model-context-protocol) is the precedent for what a donation does. It moved to AAIF on 9 December 2025 with "Over 97 million monthly SDK downloads", and its post said: "For MCP little changes." Its next spec release came on 28 July 2026, seven and a half months later. It made the protocol core stateless, retired the `initialize` handshake and added a deprecation policy with a 12-month minimum window ([release post](https://blog.modelcontextprotocol.io/posts/2026-07-28/)). The same post reports "close to half-a-billion downloads a month" across the Tier 1 SDKs, a different base from December's figure. The August [roadmap post](https://blog.modelcontextprotocol.io/posts/mcp-roadmap/) adds a contributor ladder and working groups that triage proposals in their own area. The same people stayed in charge: Soria Parra leads both MCP and now Agent Skills. Reading MCP's year as a forecast, which is my inference and not AAIF's, the skills spec will change slowly. MCP's first year at the foundation brought one release and more process rather than new features, and the skills spec's contributing guide says "When in doubt, leave it out." The first arguments are more likely to be over the `.agents/skills/` folder and the three ways of turning off automatic invocation than over new fields. MCP has also adopted skills. Its final Skills extension, SEP-2640, serves `SKILL.md` folders from an MCP server and leaves the format "delegated entirely to the Agent Skills specification" ([SEP-2640](https://modelcontextprotocol.io/seps/2640-skills-extension)), though "SDK and host support is still being implemented" ([overview](https://modelcontextprotocol.io/extensions/skills/overview)). ## What shipped on 22 October and what is only proposed What shipped on 22 October 2026 is the announcement: the name, logo, GitHub organization and domain, and two named lead maintainers. The spec repository had not changed since 9 August, and its contributing file still says "Logo requests are reviewed by the Anthropic team." Versioned releases, a formal proposal process and security guidance for people who write and install skills are proposals. For anyone installing other people's skills, security guidance is the gap. GitHub's docs warn that skills "are not verified by GitHub and may contain prompt injections, hidden instructions, or malicious scripts," and suggest `gh skill preview` before installing. Simon Willison [wrote](https://simonwillison.net/2026/Oct/22/donating-agent-skills/) that he "called this one last December"; at the time he called the spec "quite heavily under-specified." ## Who needs to change anything after the donation Nobody has to edit a valid skill: the six fields and the folder layout are the same as on 21 October. Two groups have work to do. Teams mixing Claude Code with another agent keep skills in `.claude/skills/`, which Copilot, VS Code, Cursor, OpenCode, goose and Amp also read, or keep one copy in `.agents/skills/` and symlink each skill folder into `.claude/skills/`, which Claude Code's docs support. Anyone uploading Claude Code skills to claude.ai or the Skills API has to strip non-spec keys: there, Claude Code's [docs](https://code.claude.com/docs/en/skills) say, "packaging or upload fails with a hard error instead of ignoring the field." Writing for the standard means the six spec fields and a body that makes sense without Claude Code's variables. Behaviour that only one agent supports, such as a hook, `context: fork`, a model choice or MCP wiring, goes in that agent's own layer. My repository runs both: skills with `argument-hint` in `.claude/skills/`, and spec-only wrappers in `.agents/skills/` for Codex that point back to the Claude Code commands. On Stackness, as of 23 October 2026, 8 public stacks without bots list Claude Code, 7 list Cursor, 3 OpenCode and 2 Codex ([data sources](https://stackness.dev/about/data-sources)). The numbers are small, and the [AI tools developers list in their stacks](https://stackness.dev/categories/ai-tools) show the rest of the agent layer. ## Where to start with Agent Skills Run `skills-ref validate` on one of your skills to see whether it sticks to the spec, then open it in a second agent from the table above and check that it triggers. If you only use Claude Code, nothing changes; if your team uses two agents, keep the canonical copy in one folder and symlink each skill folder into the other. The [post on non-code skills](https://stackness.dev/blog/agent-skills-for-design-and-writing-what-a-non-code-skill-loads-and-when-it-makes-output-worse) measures how many tokens a skill loads when it fires, and the move [package domain workflows as reusable agent skills](https://stackness.dev/moves/package-domain-workflows-as-reusable-agent-skills) shows the habit in a real stack. ## Agent Skills in brief - **Licence:** Apache 2.0 for code, CC BY 4.0 for documentation. - **Version:** none. The repository has no tags or releases as of 23 October 2026. - **Cost to join:** none. Anthropic: "You can continue to use the standard or contribute to it without joining the AAIF." - **Skills over MCP:** specified in SEP-2640, with host support still in progress. ## New posts by email About one email a week with what we published. No account needed. ## Which of these do you use? Nobody on Stackness runs Goose yet. Tick what you use and be the first. [Play Lonny Eagle Amateur Skater 4A pixel art skateboarding game. Signing up opens it straight away.Sign up to play](https://stackness.dev/games/lonny-eagle)