Google Open-Sources Stitch Skills: A New Practice in AI Agent Skill Standardization

From Tool Calling to Skill Encapsulation: A New Paradigm in Agent Development

Google Labs recently open-sourced the stitch-skills project, which quickly gained traction on GitHub—adding 101 stars in a single day, with a cumulative star count surpassing 6,500 and over 900 forks. Written in TypeScript, the project has a clear positioning: it's an Agent skill library designed specifically for the Stitch MCP server, adhering to the Agent Skills open standard.

The project's significance lies not in the amount of code itself, but in the direction it represents—upgrading AI Agent capabilities from scattered tool calls into reusable, composable, standardized skill modules. For developers who have long followed AI programming and the Agent ecosystem, this is a signal worth studying in depth.

What Is the Agent Skills Open Standard

The Fundamental Difference Between Skills and Tool Calling

Over the past year, MCP (Model Context Protocol) has gradually become the de facto standard for connecting large models with external tools. MCP is an open protocol proposed and driven by Anthropic in late 2024, aimed at establishing a standardized communication interface between large language models and external tools and data sources. Before MCP appeared, each AI product vendor defined its own tool-calling format—OpenAI had Function Calling, various Agent frameworks had their own plugin systems, and the ecosystem was highly fragmented. Through a unified JSON-RPC protocol, MCP defines the standard interaction between the Server (tool provider) and the Client (model/Agent), allowing an MCP server to be called by any AI client that supports the protocol. From late 2024 to early 2025, mainstream AI development tools such as Cursor, Claude Desktop, and Zed successively announced support for MCP, marking the protocol's rapid rise to de facto standard status.

But MCP primarily solves the problem of "how large models call external capabilities," whereas Agent Skills goes a step further, attempting to define what "a complete capability unit that an Agent can understand and execute" should look like. If MCP defines the "interface form of a tool," then Agent Skills defines the "complete specification of an executable task unit." A standards-compliant Skill typically declares its metadata, input/output contracts, the list of MCP tools it depends on, and its execution semantics through a structured description file (such as JSON or YAML), which the Agent runtime can use to automatically discover, understand, and orchestrate the skill. This design philosophy draws on the software engineering concept of "programming to an interface"—separating "what it can do" from "how it does it," so that skill consumers (various Agents) can invoke it without needing to understand the underlying implementation details.

Simply put, a "skill" is not just a function call—it typically includes:

• The context and prompt templates needed to trigger the capability
• The logic for calling underlying tools (via MCP)
• The orchestration flow for processing return results and performing multi-step reasoning
• The conventions for interacting with users or other Agents

The core value of stitch-skills is that each skill strictly adheres to this open standard, thereby ensuring cross-platform compatibility. Similar to the relationship between OpenAPI and REST APIs, the Agent Skills standard attempts to establish a common language for publishing and consuming AI capabilities.

Why Open Standards Matter

The greatest significance of an open standard is avoiding ecosystem fragmentation. When every vendor defines Agent capabilities using proprietary formats, developers have to reinvent the wheel for different platforms. A unified standard means "write once, run anywhere," dramatically reducing migration and integration costs. The success stories of organizations like the Linux Foundation and CNCF (Cloud Native Computing Foundation) have amply demonstrated this: driving open standards at the infrastructure layer often allows entire ecosystems to expand at an exponential rate.

Broad Compatibility with Mainstream Programming Agents

According to the project description, the skills in stitch-skills can work with the following mainstream programming-focused AI Agents:

• Antigravity: Google's own AI programming environment
• Gemini CLI: The command-line tool for Google Gemini
• Claude Code: The programming Agent launched by Anthropic
• Cursor: The widely popular AI-native code editor

This compatibility list is quite telling. It spans the product boundaries of Google, Anthropic, and even third-party vendors (Cursor), indicating that this skill standard is not a walled garden but aspires to become an industry-wide carrier of capabilities.

Here, Google is both a standards driver and proactively compatible with competitor Anthropic's Claude Code—this stance of "open coopetition" is increasingly common in today's AI infrastructure competition. This model is nothing new: proactively opening up at the infrastructure layer and attracting competitors to jointly participate in standards building often gives the standard's driver greater ecosystem influence. For Google, having products like Claude Code and Cursor support stitch-skills means that capabilities built on the Stitch MCP server can reach a broader base of developers, indirectly expanding the influence of Google's cloud services and AI infrastructure. For competitors, supporting the standard also lets their own products gain a richer skill ecosystem, forming a positive-sum game for both sides. This "trading openness for ecosystem" strategy is essentially a battle for developers' mindshare and dominance over ecosystem standards, and it is becoming the mainstream path for big tech companies competing for AI developers.

The Architectural Role of the Stitch MCP Server

A Three-Layer Architecture Design

From an architectural perspective, the entire system can be broken down into three layers:

1. Underlying capability layer: The Stitch MCP server, responsible for exposing specific tools and resources
2. Skill encapsulation layer: The stitch-skills library, which wraps underlying capabilities into standardized, task-oriented skills
3. Agent execution layer: The programming Agents that actually run the skills, such as Gemini CLI, Claude Code, and Cursor

This layered design makes responsibility boundaries clearer: the MCP server focuses on "what capabilities to provide," the skill library focuses on "how to elegantly use these capabilities," and the various Agents focus on "which skills to invoke in which scenarios."

Why TypeScript Was Chosen

It's no surprise the project chose TypeScript as its primary language. TypeScript's strong type system is naturally suited for defining the input/output schemas of skills—using interfaces and types to precisely describe tool parameters and return values, combined with runtime validation libraries like Zod, allows many interface-mismatch problems to be caught during the development phase. In the AI Agent domain, incorrect tool-call parameter formats are one of the main causes of Agent failures, and strong type constraints can significantly improve reliability. Furthermore, the maturity of TypeScript/JavaScript runtimes (Node.js, Deno, Bun) in cross-platform deployment, along with the richness of the npm ecosystem's over 2 million packages, provides a solid foundation for the skill library's dependency management. Although Python dominates the AI/ML field, TypeScript's engineering advantages are more pronounced when building structured protocol implementations and developer-facing tools. For an open standard hoping to be widely adopted, lowering the barrier to entry for developers is crucial, and the popularity of the JavaScript/TypeScript ecosystem meets exactly this need.

What It Means for AI Agent Developers

A Reusable Skill Ecosystem Is Taking Shape

The popularity of stitch-skills reflects the community's strong demand for "standardized Agent capabilities." In the past, building AI applications consumed enormous effort writing glue code, debugging prompts, and handling tool-calling edge cases. The skill library model allows these best practices to be crystallized into something reusable and shareable.

It's foreseeable that more and more "skill marketplaces" will emerge in the future, where developers can directly import mature Agent skills—just like installing npm packages—without building from scratch. This analogy reveals the ultimate form of Agent capability standardization: the reason the npm ecosystem succeeded is that it solved three core problems—version management (semantic versioning), dependency resolution (automatically handling the dependency tree), and a discovery mechanism (a unified registry). A mature Agent skill marketplace must likewise solve these three problems: how skill version iterations maintain backward compatibility, how calling dependencies between skills are declared and resolved, and how developers can efficiently discover and evaluate available skills. The current stitch-skills is closer to the early stage of the npm ecosystem—a small number of high-quality packages maintained by authoritative sources, without yet forming an open community contribution ecosystem. From this perspective, the key metric for measuring the project's success is not the number of GitHub stars, but whether enough third-party developers will contribute new skills according to the standard in the future, and whether a sustainable skill discovery and distribution mechanism will form.

Evaluate Rationally, Adopt with an Experimental Mindset

Of course, the ultimate direction of the standards battle remains unclear. Whether the Agent Skills open standard will truly be widely adopted by the industry depends on whether enough vendors and developers continue to invest. The current high star count reflects community interest more than proof of maturity.

For teams eager to try it out, we recommend adopting it with an experimental mindset, focusing on evaluating: skill stability, documentation completeness, and the cost of adapting it to existing Agent toolchains.

Summary

stitch-skills is a microcosm of the AI Agent ecosystem moving toward standardization and modularization. It grounds the abstract concept of "skills" in runnable, reusable engineering practices, and connects multiple mainstream programming Agents through an open standard.

After MCP, Agent Skills may become the next key infrastructure layer. No matter which standard ultimately prevails, this effort to drive capability standardization is a boon for the entire developer community. Interested readers are encouraged to visit the GitHub repository and study the concrete implementation of its skill definitions in depth.

Key Takeaways