What Is Agent Skills as an Open Standard? How Claude, OpenAI, and Google Adopted the Same Format

The Convergence Nobody Officially Announced

Three major AI labs — Anthropic, OpenAI, and Google DeepMind — each settled on nearly the same format for describing what an AI agent can do. There was no standards committee, no joint announcement, and no formal specification. And yet today, a skill definition written for Claude can be adapted for GPT-4o or Gemini in minutes.

That quiet convergence is what “Agent Skills as an open standard” actually refers to. It’s also why the Agent Skills format has more practical significance for multi-agent AI than MCP does — even though MCP gets considerably more developer attention.

This article covers what Agent Skills are, how the format emerged and why all three providers converged on the same approach, and what this means for building real multi-agent workflows.

What Agent Skills Are

An agent skill is a discrete, structured capability description — a way of telling an AI system, or another AI agent, what a given function does, what parameters it accepts, and what it returns.

Every skill definition typically includes:

A name: what the skill is called
A description: what the skill does, in natural language
An input schema: the parameters the skill accepts, including types, descriptions, and required vs. optional fields
An output format: what the skill returns
An invocation method: how to actually trigger it

This isn’t novel in software engineering. APIs have had documented endpoints for decades. What makes agent skills different is that the description is written for an AI model to reason about — not just for a human developer reading documentation.

When an AI agent reads a skill definition, it uses the natural-language description to decide when to call the skill and how to construct valid inputs. The schema ensures the call is structurally correct. Together, those two components allow agents to make context-aware decisions about capability use.

Skills vs. Tools vs. Functions vs. Plugins

The terminology varies by platform. OpenAI uses “functions” and “tools.” Anthropic calls them “tools.” Google uses “function declarations.” Microsoft’s Semantic Kernel originally called them “skills” before rebranding them “plugins.”

Throughout this article, “Agent Skills” refers to the underlying concept: a schema-defined capability that an agent can advertise to other systems and invoke with structured inputs. The format that converged across all major providers is based on JSON Schema — an open specification for describing JSON data structures that was already widely used well before AI agents became common.

How the Format Emerged

OpenAI introduced function calling in mid-2023, letting GPT-3.5 and GPT-4 models invoke external functions by generating a structured JSON payload. The definition format looked like this:

{
  "name": "get_weather",
  "description": "Get the current weather for a location",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "City and state, e.g. Austin, TX"
      }
    },
    "required": ["location"]
  }
}

Anthropic followed with tool use for Claude — functionally identical in design, with a nearly identical schema format. Google’s Gemini API added function declarations using the same JSON Schema approach.

By 2024, all three major providers accepted tool and function definitions in formats that differed only in minor surface details: where you pass them in the API, what the wrapper objects are named, how the model signals intent to use a skill in its response. The underlying parameter schema was essentially the same across all three.

Why JSON Schema Specifically?

JSON Schema was the practical choice for several reasons:

It’s already widely used for API documentation and data validation
It’s human-readable and machine-parseable simultaneously
It handles all the types LLMs need: strings, numbers, enums, arrays, nested objects
It required no new specification — just an application of existing tooling

The practical result: a skill written in JSON Schema is portable across providers with minimal adaptation. The convergence wasn’t coordinated. It was inevitable given that everyone faced the same technical requirements.

How Claude, OpenAI, and Google Each Implement Skills

The differences between the three implementations are real but shallow. Here’s where each provider stands today.

Claude (Anthropic)

Claude’s tool use accepts an array of tool definitions, each with name, description, and input_schema. The input_schema field uses JSON Schema format directly. Claude returns a tool_use content block containing the skill name and arguments when it decides to call one.

Anthropic has been explicit that the description field heavily influences call accuracy. A well-written description improves when and how Claude chooses to invoke a skill — more so than tweaking the schema structure.

OpenAI (GPT-4, GPT-4o)

OpenAI wraps tool definitions in a tools array. Each entry specifies type: "function" and a nested function object with name, description, and parameters (JSON Schema). The model returns a tool_calls array when it decides to invoke a capability.

OpenAI’s Agents SDK, released in early 2025, builds on this foundation with structured handoffs between agents and higher-level abstractions for multi-agent coordination — the same underlying skills format, extended upward.

Google (Gemini, Vertex AI)

Google uses FunctionDeclaration objects with name, description, and parameters (JSON Schema). The model returns functionCall parts when it wants to invoke a capability. Vertex AI adds deployment infrastructure on top, but the underlying declaration format aligns with the others.

The Shared Pattern

Across all three providers:

Descriptions are natural language, written for AI reasoning
Parameters use JSON Schema
The model returns structured data — not free-form text — when it decides to use a skill
The calling application handles execution and returns results

This isn’t coincidence. It’s practical convergence on the format that actually works. Writing a cross-provider skill adapter is achievable. Most of the logic is identical.

Agent Skills vs. MCP: Why the Distinction Matters

MCP (Model Context Protocol), announced by Anthropic in late 2024, has attracted significant developer interest. It’s a well-designed protocol for a specific problem: how an AI model connects to external data sources and tools.

But that problem is different from what Agent Skills solves.

What MCP Solves

MCP is a client-server protocol. The AI model is the client; external tools and data sources are the servers. MCP standardizes how a single AI agent accesses external resources — databases, file systems, APIs, custom tools.

It solves the connection problem: how does one AI agent access what it needs from the outside world?

What Agent Skills Solves

Agent Skills solves the interoperability problem: how do multiple AI agents, potentially from different providers, describe and share their capabilities with each other?

This becomes critical in multi-agent architectures where:

An orchestrator agent routes tasks to specialized sub-agents
Sub-agents are built on different providers (Claude, GPT, Gemini, fine-tuned models)
External AI systems like Claude Code or LangChain need to call your agent’s capabilities
Agents need to discover what other agents can do at runtime

MCP doesn’t address this. It’s about one agent accessing tools — not about agents coordinating with each other.

The Practical Hierarchy

MCP → one AI model, connecting to many tools and data sources
Agent Skills → many AI agents, sharing and invoking each other’s capabilities

For simple single-agent setups, MCP handles the hard part well. But as deployments grow more complex — multiple specialized agents, provider-agnostic orchestration, shared capability registries — the Agent Skills standard becomes the essential coordination layer.

The industry is clearly moving toward multi-agent architectures. That trend makes agent-to-agent interoperability more pressing than agent-to-tool connection, which MCP already addresses.

What This Means for Multi-Agent Workflows

The practical payoff of a shared skills format is that you can build agent networks that aren’t locked to a single provider.

Consider a realistic document processing workflow:

An orchestrator agent (Claude-based) receives a raw document and determines what processing it needs
A classification agent (GPT-based) categorizes the document type and extracts key entities
A formatting agent (Gemini-based) restructures the content for a target template
A quality-check agent (Claude-based) reviews the output before delivery

For this to work cleanly, each agent needs to:

Advertise its capabilities in a format the orchestrator understands
Accept structured inputs from other agents
Return structured outputs the next agent can parse reliably

The converged skills format makes this possible. Each agent exposes its capabilities as a skill manifest. Any orchestrator that understands the format can call them — without custom glue code between every pair of agents.

Skill Registries and Dynamic Discovery

More advanced multi-agent systems maintain skill registries — catalogs where agents can discover what other agents are capable of at runtime. An orchestrator reads skill descriptions, reasons about which capabilities are relevant for a given task, and constructs valid calls.

This is the same reasoning loop LLMs already use for tool calling. Extending it to agent-to-agent coordination is the natural evolution — and it only works reliably if the skill format is standard enough to be reasoned about consistently.

How MindStudio Fits Into the Agent Skills Ecosystem

MindStudio’s Agent Skills Plugin (@mindstudio-ai/agent) is a practical implementation of this pattern as a developer-friendly npm SDK.

It exposes 120+ typed capabilities as simple method calls that any AI agent can invoke:

await agent.sendEmail({ to: "user@example.com", subject: "...", body: "..." });
await agent.generateImage({ prompt: "...", style: "photorealistic" });
await agent.searchGoogle({ query: "...", numResults: 5 });
await agent.runWorkflow({ workflowId: "...", inputs: { ... } });

The SDK handles the infrastructure that most agent developers would otherwise build themselves: authentication, rate limiting, retries, structured output parsing. Agents focus on reasoning. The SDK handles the plumbing.

Because the capabilities are typed and schema-defined, they fit naturally into the Agent Skills pattern. Any agent that understands the standard — Claude Code, LangChain, CrewAI, a custom orchestrator — can call MindStudio capabilities without building integrations from scratch.

For teams that want to build multi-agent workflows without writing code, MindStudio’s visual builder supports the same multi-agent patterns. You can create orchestrator-agent architectures, connect to 1,000+ business tools, and deploy agents that work across Claude, GPT, Gemini, and others from a single platform — without managing separate API keys or accounts for each model.

You can start free at mindstudio.ai.

Frequently Asked Questions

What is an agent skill in AI?

An agent skill is a structured, machine-readable description of a capability that an AI agent can perform. It specifies what the capability does (in natural language for the model to reason about), what parameters it accepts (via JSON Schema), and what it returns. Skills let AI agents advertise and invoke each other’s capabilities in a standardized way.

Is Agent Skills officially an open standard?

Not in the sense of a formal standards body. It’s more accurately described as a de facto standard — a format that emerged through independent convergence across Anthropic (Claude), OpenAI, and Google (Gemini). All three independently settled on JSON Schema-based function and tool definitions. The practical interoperability is real even without a formal specification document.

How is Agent Skills different from MCP?

MCP (Model Context Protocol) standardizes how a single AI model connects to external tools and data sources. Agent Skills standardizes how multiple AI agents describe and share capabilities with each other. MCP solves agent-to-tool connection. Agent Skills solves agent-to-agent interoperability. They’re complementary — MCP handles one layer, Agent Skills handles another.

Why did Anthropic, OpenAI, and Google all converge on the same format?

JSON Schema was already the most practical available option: widely used, well-documented, machine-parseable, and expressive enough to handle complex nested parameter structures. Each provider independently needed a format that an AI model could reason about when selecting tools — and JSON Schema satisfied that requirement without requiring a new specification.

Can a skill written for Claude work with GPT or Gemini?

Mostly yes. The underlying JSON Schema for parameters is the same across providers. The differences are in how you pass skill definitions to the API (the wrapper structure) and how the model signals intent to invoke a skill in its response. Adapting a skill definition across providers typically takes minutes. The core fields — name, description, parameters — stay the same.

What is the MindStudio Agent Skills Plugin?

It’s an npm SDK (@mindstudio-ai/agent) that exposes MindStudio’s 120+ capabilities as typed method calls. It lets any AI agent — Claude Code, LangChain, CrewAI, or a custom orchestrator — invoke capabilities like agent.sendEmail() or agent.generateImage() without building the underlying integrations. The SDK handles auth, retries, and rate limiting, so agents focus on reasoning rather than infrastructure.

Key Takeaways

Agent Skills is a structured, schema-based format for describing AI agent capabilities — converged independently across Claude, OpenAI, and Google into a de facto open standard.
The format is based on JSON Schema, making skill definitions largely portable across providers with minimal changes.
Agent Skills and MCP solve different problems: MCP handles agent-to-tool connection; Agent Skills handles agent-to-agent interoperability.
In multi-agent architectures, a shared skills format is what allows agents from different providers to coordinate without custom integration work for every pair.
MindStudio’s Agent Skills Plugin is a practical implementation — giving any AI agent access to 120+ typed capabilities while handling infrastructure behind the scenes.

If you’re building multi-agent workflows and want to skip rebuilding the integration layer from scratch, try MindStudio free — the platform is built for multi-step, multi-agent AI work.