Building Custom AI Skills
Building custom AI skills is the practice of packaging reusable capabilities so that AI agents can perform specialized tasks reliably. A skill is a directory containing a SKILL.md file that contains organized folders of instructions, scripts, and resources that give agents additional capabilities[^c1] — more precisely, a folder whose YAML frontmatter carries a name and a description, followed by Markdown instructions, that an agent discovers at startup and loads only when a task matches[^c11]. The format is governed by a small, open specification with strict field constraints — the name is capped at 64 lowercase alphanumeric and hyphen characters[^c23] — so a skill is defined as precisely as a package manifest. Skills are the application layer of a broader stack: models reason, tools act, and skills encode the procedure that decides which actions to take and in what order. Because capabilities can be added without retraining, skills have become an important mechanism for capability development and distribution[^c8], and the format has spread across vendors faster than almost any prior agent standard: in under nine months agent skills went from a single product feature to a cross-vendor standard with dozens of compatible platforms and millions of published skills[^c6]. Distribution then consolidated into packs and indexed catalogs: one release packages 133 skills into eight domain packs[^c56], a weekly-refreshed index lists 1,402 skills drawn from eleven repositories[^c55], and the most-starred repositories are distinguished less by prompt text than by turning software practice into repeatable workflows[^c54][^c53]. By 2026 the format had moved beyond AI tooling entirely, with a patch series proposing that the Linux kernel adopt a top-level agents/ directory holding skills, each in its own folder under agents/skills/ with a SKILL.md entry point[^c27]. Platform vendors responded by shipping first-party libraries of their own: Google open-sourced an official Android skill library scoped to workflows where evaluations show models underperform[^c39], and comparable official collections established that vendor-authored skills are a distribution layer in its own right.
Portability became an explicit product feature during 2026 rather than a property inferred from the file format. Notion's workspace can write a skill once and synchronize it across ChatGPT, Claude, and other agents through a Skills API[^c43], backed by a database-hosted skills library that gives a team one hub for shared instructions[^c65]; Laravel's agent SDK implements a HasSkills contract that returns skill directories, PHP objects, or per-team closures[^c44]; and Builder.io's Agent-Native framework defines each capability once and exposes it to the UI, the agent, an HTTP API, a command-line interface, MCP, and A2A[^c45]. The same shift appeared in developer conventions: the AGENTS.md format, stewarded by the Agentic AI Foundation, remains plain Markdown with the filename fixed case-sensitively[^c51]. The foundations of that stack are function calling and retrieval. Function calling lets a model request that an application execute a named operation, returning a structured result that the model incorporates into its response; the providers agree on what a tool is, but each wraps it in its own request and response format, and the formats do not interchange[^c33], which is why cross-provider portability is a design decision rather than a given. Retrieval-augmented generation grounds outputs in external knowledge through embeddings and vector search. The Model Context Protocol standardizes tool access across hosts, so that an agent can discover capabilities at runtime — it calls the tool listing, sees what is available, and decides which tools to invoke autonomously[^c2] — rather than relying on hardcoded integrations. MCP has become the near-universal standard for connecting models to tools and data, with thousands of public servers in production use[^c7], and monthly downloads of its official SDKs passed 400 million during 2026[^c19]. The protocol itself reached a milestone revision in 2026 that transformed it from a bidirectional stateful protocol into a request-and-response stateless one[^c12], making MCP servers deployable on ordinary web infrastructure at scale. It now sits alongside the Agent Skills standard and the Agent-to-Agent protocol under neutral foundation governance, and the skills extension that carries skills over MCP reached Final status with a complete reference implementation[^c16]. Vendor-operated servers arrived at the same time: a stable release of Microsoft's Azure server for its cloud platform gives compatible agents a consistent way to discover and call those services[^c32]. Two developments extended the infrastructure further. The registry indexing MCP servers reached 42,753 entries by mid-October[^c34], and the protocol's reach moved beyond software: a companion open specification, the Model Hardware Standard, was introduced to let agents safely operate physical laboratory instruments, liquid handlers, and robotic arms[^c35], opening as a research preview on 27 August 2026[^c66], with pilot results that included a laser relock success rate rising from 58% to 99.3% over 695 of 700 trials and recovery in seconds instead of minutes[^c49]. Servers themselves shifted from per-machine installs to hosted endpoints, so that a vendor's tool interface is reached over HTTP with nothing to install or maintain[^c37], and survey data cited by security vendors put production MCP use at nearly half of software companies, with roughly a fifth reporting broad deployment[^c38] — which is why securing the integration layer became a product category in its own right.
Skills themselves are governed by a design discipline. Progressive disclosure — the core principle that makes agent skills flexible and scalable[^c3] — keeps only a skill's name and description resident until a task matches, so a library can grow without consuming the model's attention budget on every request. The economics of that choice are exact: reading a skill costs nothing that persists, keeping one costs a folder in the repository, and only firing unprompted costs the prompt[^c10]. Runtime routing matured alongside the format: platform search tools now locate an installed skill by name, description, or instruction text and read its full contents on demand rather than placing the whole library in the prompt[^c57]. Authoring practice converges on a small set of habits: keep skills focused, write descriptions that trigger reliably, keep references shallow, and build evaluation suites that compare output with and without the skill. Evaluation became its own tooling category, with test-driven authoring loops that run cases in parallel and compare two skill versions blind[^c36]. A harder design problem is composition, because skills arrive from many sources and are frequently installed in bulk: nearly one in four installed skills is co-installed with another that does the same job[^c25], and deliberately co-activated skills can impose incompatible requirements, competing preferences, and redundant instructions when jointly loaded[^c26]. Reliable composition therefore depends on making conflicts explicit — routing genuine conflicts, resolving competing preferences into one formulation, and deduplicating the rest — and on preventing accidental ones through narrow scope and deterministic guards at the point where the agent first reads a skill. A newer research direction treats the library as something that maintains itself: systems that evolve skills from real interactions[^c20], and curated libraries that retrieve the right skill rather than merely accumulating them — curated retrieval raised measured skill-benchmark performance from 9.2% with no skills to 22.6%, while dumping in a raw crawl of hundreds of thousands of skills reached only 14.9%[^c21]. Agents are also beginning to author their own tools, with research showing that a model can learn to build tools, refine them, and share proven ones across model sizes[^c24]. The paradigm now extends to embodied and scientific work: NVIDIA's ASPIRE harness persists validated robot control skills into a library spanning more than 90 skills across 150 tasks and 18 categories[^c40], and a 177-skill scientific collection moved from a single vendor's format onto the open standard and now covers biology, chemistry, medicine, physics, engineering, earth science, data analysis, and scientific communication[^c41]. Frameworks have followed by making skills a native primitive with policy attached; one mainstream Python framework now honours invocation flags and rejects paths outside the configured skill library[^c42].
The ecosystem's central lesson is that reach is not quality. Distribution is solved — skills are now published through plugins that bundle connectors and instructions into a single installable unit[^c17], and the same manifest format is used across vendors, including by companies publishing first-party skills in a competitor's format[^c18] — but many public skills are weak or unsafe, and the catch is quality variance[^c9]. The risk is measurable: a large-scale security study of tens of thousands of published skills found that roughly a quarter contained at least one vulnerability, spanning prompt injection, data exfiltration, privilege escalation, and supply-chain patterns[^c13], which places skill vetting alongside dependency review as a production concern. Marketplace operators have responded with safety-scanned submission portals and reviewed directories[^c14], but open community catalogs remain largely unaudited. Above the protocols sit frameworks and platforms that structure multi-step work, and the shape of that layer shifted during 2026. Frameworks range from graph-based orchestration to role-based agent teams and conversational multi-agent collaboration, but the category increasingly reframed itself around the harness — a runtime above the model, orchestrating swappable plugins, in contrast to a framework the agent lives inside[^c28] — and the clearest such runtimes began shipping context compaction, memory, skills, tool approval, and tracing as default components rather than optional add-ons. Skills became a native framework primitive: Mastra follows the Agent Skills specification and exposes discover, read, and search tools to its agents[^c61], Laravel prunes large tool lists by loading rarely used tools on demand[^c62], and Agent-Native stores skills under a conventional directory path[^c63]. Production-hardening releases concentrated on the concerns that appear at scale: multi-tenant agent scopes that route memory and threads by organization, resource, and conversation[^c46], durable harnesses that persist task state and resume after a crash[^c47], and public-preview harnesses built entirely from replaceable plugins[^c48]. The harness itself also became an optimization target: Google's Harness² edits its own prompts, toolchains, and skill library, raising GLM-5's WorkBuddy-Bench score by 11.5 points and transferring accumulated experience across benchmark domains[^c58][^c59][^c60]. Hosted platforms supply managed runtimes, memory, retrieval, identity, and observability, together with marketplaces and directories through which reviewed connectors and skills are distributed. The infrastructure market also split during 2026 between usage-metered services and flat-price subscriptions that bundle compute, tools, and security, a change framed as betting that predictable pricing matters as much as architectural parity[^c22]. Alongside protocols for tools and agents, a third standardization layer emerged for agent-to-user interaction, where an open, event-based protocol carries everything the user sees — text, tool calls, reasoning, shared state, and progress — as one ordered stream of typed events to the application[^c31]. Conventional tool protocols evolved in parallel: the Universal Tool Calling Protocol reached a plugin-based 1.0 core and later a 1.2 release, with secure-by-default rules that confine a tool manual to its own communication protocol unless explicitly widened[^c50]. Selection and economics cut across all of it. Benchmark fragmentation means no single model or framework dominates, and the durable finding is that orchestration choice matters less than the quality of the context agents reason over[^c4]. Cost behaves the same way: because output tokens are the dominant cost driver on almost every workload[^c5], caching, routing, context trimming, and local-versus-cloud execution matter as much as model choice, and automated optimization against a held-out evaluation can cut cost while improving quality — one documented loop moved a support agent to a smaller model at low effort, scoring higher at a fraction of the cost per ticket[^c15]. Two operational gaps remain easy to assume away: human approval became a framework default, but the design question that matters is where a paused approval lives, in the running process or in a serialized object that survives a redeploy[^c30]; and approval is not a budget, because no major framework enforces a spending limit expressed in currency[^c29]. The year also produced concrete oversight failures rather than hypothetical ones, including unauthorized agent activity on Wikimedia infrastructure and hundreds of thousands of automated queries against a shared public service[^c52]; risk-tiered oversight models now assign in-the-loop, on-the-loop, or out-of-the-loop control by severity and reversibility, on the principle that observability must precede autonomy[^c64]. Evaluation, guardrails, security, and deployment round out the lifecycle, because a skill that cannot be tested, constrained, or rolled back safely is not production-ready.