Agent Skills Explained: the Open Standard Now Running on 70 Platforms

Key Takeaway

• 📦 What happened: Anthropic donated Agent Skills — the open standard that teaches AI agents a task through a folder with a SKILL.md file plus scripts — to the Agentic AI Foundation under the Linux Foundation on October 22, 2026, including the name, logo, GitHub organization and the agentskills.io domain.
• 🌐 Why it matters: more than 70 agent platforms have integrated Agent Skills since the standard was published in December 2025 — including ChatGPT, Cursor, GitHub Copilot and VS Code — so a skill written once now runs across platforms that used to be walled off from each other.
• 🏛️ The neutral home: the Agentic AI Foundation (AAIF) sits under the Linux Foundation like Kubernetes sits under the CNCF; it was co-founded by Anthropic, Block and OpenAI, it already hosts the Model Context Protocol (MCP), and its Platinum members include AWS, Google, Microsoft, Cloudflare and Bloomberg.
• 🛠️ What you can do: skills written by teams keep working unchanged; you can use and contribute to the standard without joining the foundation; and the practical play is to write your team’s repeatable procedures as skills now, because the format that packages them just became infrastructure.
• 🧭 How to read it: the donation converts a vendor feature into vendor-neutral infrastructure — the same move that made MCP the agent-integration layer — and it puts “write a skill” on the same skills-shortlist as “write a prompt” for 2027 workflows.

Agent skills just moved from company feature to public infrastructure — and the agent skills standard now runs on 70 platforms. On October 22, 2026, Anthropic donated Agent Skills — the open standard that gives AI agents reusable instructions and workflows — to the Agentic AI Foundation (AAIF), an independent foundation under the Linux Foundation that Anthropic co-founded with Block and OpenAI. The donation covers the Agent Skills name and logo, the GitHub organization that holds the specification, and the agentskills.io domain. The reason it matters to any team using AI tools: more than 70 agent platforms — ChatGPT, Cursor, GitHub Copilot and VS Code among them — already integrated Agent Skills since the standard was published in December 2025, which means the folder you package for Claude also loads in your editor’s agent. This guide explains what a skill actually is, what changed and did not change in the donation, how skills differ from MCP, and how to write one for your own workflows.

What agent skills are: a folder that teaches

The definition, concrete: an agent skill is a folder containing a SKILL.md document — instructions that teach an agent one task — plus any scripts and reference material the task needs. That is the whole format: no SDK, no runtime, no lock-in mechanism. A customer-support skill might carry the escalation policy as a Markdown document, the refund approval thresholds as a reference sheet, and a script that formats tickets. When an agent loads the skill, it reads the instructions and works the task the way the team works it.

The problem skills solve: before this format, teams repeated their procedures in chat prompts — “when handling refunds, always check X, escalate Y, use this template” — re-explained per tool, per teammate, per month. The skill packages that procedure once, portable across every agent platform that reads the standard. The pattern is the tool-layer equivalent of what the MCP integration layer did for connections: write the binding once, reuse it everywhere. And like MCP, the winning move was neutrality — which is exactly what the October donation buys.

Why the format is winning: it rides existing habits. Teams already maintain runbooks and checklists; SKILL.md is a runbook an agent can read. The friction is nearly zero (a folder, a Markdown file), versioning is natural (git), and the skills travel with the person, not the employer — which is why adoption spread to 70-plus platforms inside a year of publication.

The October 2026 donation: what changed and what did not

What changed (the transferred assets): the Agent Skills name and logo, the GitHub organization holding the specification, and the agentskills.io domain moved to the Agentic AI Foundation under the Linux Foundation on October 22, 2026. The foundation co-founded at the end of 2025 by Anthropic, Block and OpenAI already hosts the Model Context Protocol — the same neutral-home pattern — and its Platinum membership includes Amazon Web Services, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft and OpenAI, hosting ten projects. The announcement landed alongside the Linux Foundation’s industry events (AGNTCon and MCPCon North America in San Jose), where four new projects were accepted the same day.

What did NOT change: the standard itself, the skills your team has written (they keep working unchanged), your ability to use or contribute to the spec without joining the foundation, and the roadmap proposals — versioned releases, a formal proposal process, and formal security guidance — which now become foundation-governed work items rather than one vendor’s backlog. The donation is governance, not tech: the bytes are identical the day after as the day before.

Why governance is the real story: every agent platform that integrates a vendor-owned standard carries a dependency risk — the vendor can change terms, fork the format, or gate the ecosystem. Moving the assets to a neutral foundation removes the single-vendor risk that would otherwise cap adoption (the same argument that carried Kubernetes to the CNCF and MCP to the foundation). For agencies and enterprises, the decision to write skills against the standard is now defensible in procurement language: the format has a governance home, multiple corporate stewards, and a public contribution path.

Agent skills vs MCP: two layers, not competitors

The layer map, plainly: MCP connects agents TO THINGS — tools, data sources, APIs; it is the integration layer that lets an agent reach a calendar, a database or a CMS. Agent Skills teach agents HOW TO DO a task — the procedure, judgment calls, templates and scripts; it is the knowledge layer that makes an agent behave like a trained teammate rather than a generalist. The question “Agent Skills vs MCP — which should we adopt?” is a category error, and the Foundation hosting both under one roof is the institutional answer: they compose. An agent with MCP connections and loaded skills reads the calendar through MCP and follows the firm’s booking policy through the skill.

WorldNgayon Analysis: the two-standard pair is the agent stack’s maturity moment — integrations standardized (MCP), procedures standardized (Skills) — and both now live in neutral governance. The practical consequence for any AI-using team is a cleaner make-or-buy decision: adopt the standards once, then invest your budget in writing the skills that encode YOUR judgment. That investment used to be platform-locked; it is now portable, which changes the build-versus-wait math for every small team.

Bottom Line: MCP wires the agent to your systems; Agent Skills trains it in your procedures — adopt both, own the knowledge.

How to write an agent skill: the practical anatomy

The anatomy from the format itself: a skill folder carries (1) SKILL.md — the instructions document that describes the task, its constraints and its decision rules; (2) scripts — optional executable helpers the agent can run; (3) reference material — the policy sheets, templates or data files the task reads. The SKILL.md discipline is the actual skill-writing skill: name the task precisely, define the inputs and outputs, encode the judgment calls as explicit rules, and link the reference files by relative path so the folder is self-contained.

The workflow for a first skill (the evening version): 1 — pick the most-repeated written procedure your team has (an FAQ answer, a report format, an intake checklist); 2 — write it as if briefing a competent new hire: goal, inputs, steps, edge cases, escalation rule; 3 — save as SKILL.md in a folder named after the task; 4 — add one reference file (the template, the threshold sheet); 5 — load it in one agent platform and test against three real cases; 6 — iterate until the pass rate is boring; 7 — version it in git. That last step is where the donation pays: the skill tested in one tool now travels — the same folder loads wherever your stack goes next, which is the portability the pre-donation format could only promise.

The anti-patterns to avoid: cramming multiple unrelated tasks into one SKILL.md (skills are tasks, not manuals); encoding tribal knowledge that depends on a person rather than a procedure (if it needs that person on the call, it is not a skill yet); and skipping the test pass — a skill that fails three real cases is documentation, not tooling. Teams that write five solid skills usually discover the sixth, seventh and eighth from the pattern of the first five, which is why the skill-library habit compounds.

WorldNgayon Analysis: the skill-writing craft sits exactly at the crossing point this site’s series teaches: the prompt-writing discipline (the prompt-engineering layer), the verification habit (the hallucination-defense checklist for whatever the skill’s scripts decide), and the agent-architecture map (the agent-tools ledger). A skill is a prompt with governance — write it at the standard you already hold your best prompts to, then let the portability multiply it.

Bottom Line: write the procedure you already have; the folder is the easy part — the judgment encoded is the asset.

Who uses agent skills today: the 70-platform evidence

The integration list, as reported: more than 70 agent platforms integrated Agent Skills between the December 2025 publication and the October 2026 donation — headlined by ChatGPT, Cursor, GitHub Copilot and VS Code, with the Claude Code plugin ecosystem (including partner directories like Unity’s) as the native showcase. The breadth matters because it is the market’s vote on an open format: teams no longer choose between “the skill my agent runs” and “the skill the industry runs.”

What the breadth predicts: skill libraries become shared infrastructure the way package repositories became shared infrastructure for code — public directories, team-internal libraries, and a marketplace layer where useful skills travel. The open questions for 2027 are quality and security (the foundation’s proposed security guidance and versioned releases are the governance response): a skill is executable content, and enterprises will require the same review discipline the scripts behind it deserve. The tools-solo ledger tracks where the ecosystem layer consolidates.

What this means for work, money and the Philippines

For careers: skill authorship is becoming a line-item skill — “I wrote and maintained our agent skills” is the 2027 equivalent of “I built our dashboards”: specific, verifiable, portable. The professionals who encode repeatable procedures earn the automation dividend instead of watching it pass by (the AI-jobs structural read applies).

For agencies and freelancers: skills are productizable services — a freelancer who packages an industry’s intake process as a tested skill sells the artifact, and sells migration help when clients change platforms. The portability the donation guarantees is what makes the service sellable across client stacks.

For Filipino professionals and OFWs: the format is currency-neutral and platform-neutral, which suits a globally distributed team: a skill written for an Australian client’s intake loads in a Canadian employer’s editor unchanged. The family-AI angle is the same one this site carries in the money pieces: write the household’s procedures (the budgeting checklist, the remittance-log routine from the money-minute prompts) as skills, and the procedures survive every tool migration — a small infrastructure habit with compounding returns.

For businesses: the make-or-buy decision is now lower-risk on the “make” side: standards with governance homes carry procurement defensibility. Start with the five most-repeated procedures; the library compounds from there.

Verdict: the format won; now fill it

Agent Skills, settled after the donation: the format — a folder with SKILL.md, scripts and references — is now neutral infrastructure, governed by a Linux-Foundation home that Anthropic, Block and OpenAI co-founded, with MCP beside it and eight Platinum members underneath, and 70-plus platforms reading it. Nothing about your skills changed; the portability promise underneath them got governance. The move that pays is unchanged since December: write the procedures your team repeats, test them against real cases, version them, and let the standard carry them forward. The format won — the teams that fill it with their judgment will be the ones the agents work for.

Sources on the record: Anthropic Agent Skills announcement · Linux Foundation · the official Agent Skills repository.

Financial Disclaimer

This article is editorial analysis of publicly reported information, not investment or financial advice, and no outcome is promised. Pricing and terms are as reported by the named platforms and change frequently; verify before purchasing decisions. Markets and technology platforms carry risk.

@online{agron2026agentskills,
  author       = {Agron, Edmon},
  title        = {{Agent Skills Explained: the Open Standard Now Running on 70 Platforms}},
  year         = {2026},
  date         = {2026-11-01},
  organization = {WorldNgayon},
  url          = {https://worldngayon.com/agent-skills/},
  urldate      = {}
}

TY  - ELEC
AU  - Agron, Edmon
TI  - Agent Skills Explained: the Open Standard Now Running on 70 Platforms
T2  - WorldNgayon
PY  - 2026
DA  - 2026/11/01/
UR  - https://worldngayon.com/agent-skills/
Y2  - 
ER  -