---
type: "article"
title: "The only schema language AI speaks is JSON Schema"
summary: "TL;DR: Every major LLM provider (OpenAI, Google, Anthropic, Mistral, xAI,\nDeepSeek), the Model Context Protocol, and the AI products built on them\n(agent frameworks and vertical AI APIs) have all converged on the same and\nonly schema language: JSON Schema.\nAI is plumbed into APIs, and APIs speak JSON\nAI is delivered through APIs. Every major LLM provider exposes its models\nbehind an HTTP endpoint. AI also consumes the world through APIs: tool calls\nhit REST endpoints and MCP servers expose\ncapabilities over HTTP. APIs sit on both sides of the boundary.\nThat observation is not contested. Marco\nPalladino, CTO of\nKong, writes: AI traffic is API traffic. Postman’s 2024 State of the API\nreport recorded a 73%\nyear-over-year jump in AI-related API traffic across its platform, with OpenAI\nalone accounting for 78.5% of it. The 2025\nfollow-up puts it even more\ndirectly: APIs are no longer just powering applications. They’re powering\nagents. Kin\nLane\ntreats AI agents as just another API consumer.\nAnd those APIs speak JSON. In Postman’s 2025 State of the API\nsurvey of 5,700+ developers, 93%\nreported building REST APIs, and REST APIs in practice mean JSON over HTTP.\nREST still dominates at 93% (Source: Postman 2025 State of the API)\n  \n\nJSON is what application-layer software uses to move structured data between\nprocesses, services, and organisations. The format question was settled before\nLLMs arrived.\nFrom “please respond in valid JSON, I’m begging you” to schema-enforced generation\nIf AI is delivered through APIs and APIs speak JSON, then naturally users\nwanted LLMs to talk JSON too. In 2023, getting it reliably was a notorious\nengineering pain. Workarounds piled up: regex extractors, assistant prefills\n(\"Here is your JSON output: {\"), multi-step prompting, repair loops, and even\nprompts that politely begged the model to comply. Each had its own brittle\nedge cases. Charlie Guo’s Stop begging for\nJSON is the museum tour,\nand captures perfectly what anyone shipping LLM features had lived through:\nA prompt asking the LLM to return only valid JSON, followed by the model’s mocking compliance\n  \n\nThe community treated the problem as serious enough to need dedicated\ninfrastructure. jsonformer (~5000 stars\non GitHub), an open-source library released in early 2023, opened its README by\nsaying current approaches to this problem are brittle and error-prone. The\nOpenAI developer forums in 2023–2024 were full of similar\nthreads.\nTo solve this, OpenAI famously shipped the Structured\nOutputs\nfeature in August 2024: hand the API a JSON Schema, and the model’s output is\nguaranteed to validate against it at the token level. No more begging, no more\nretry loops, no more regex extractors. The pain went from a weekly source of\nsuffering to an API parameter.\nThe choice of JSON Schema specifically wasn’t accidental. JSON Schema had been\nthe de facto schema language for HTTP APIs for years.\nOpenAPI, the dominant API description standard, is\nbuilt on top of it. AI runs on APIs. When OpenAI needed a contract language for\nthe JSON-output problem, they naturally reached for the one API engineers\nalready used.\nStructured outputs: six providers, one schema language\nStructured outputs proved indispensable beyond chat UIs, for any production\npipeline that needed to consume LLM output programmatically. As Julien\nChaumond, CTO of HuggingFace, put it: Structured\ngeneration is the future of LLMs. Within fifteen months of the first such\nlaunch, every major LLM provider had shipped equivalent support. At the time of\nthis writing, all of them support JSON Schema. Literally all of them:\nProvider\n\t\t\t\t\tLaunched\n\t\t\t\t\tDialect support\n\t\t\t\t\tNotes\n\t\t\t\nOpenAI\n\t\t\t\t\tAugust 2024\n\t\t\t\t\tUnspecified\n\t\t\t\t\tresponse_format with json_schema\n\t\t\t\nxAI / Grok\n\t\t\t\t\tDecember 2024\n\t\t\t\t\t2020-12 and Draft 7\n\t\t\t\t\tresponse_format with json_schema\n\t\t\t\nMistral\n\t\t\t\t\tJanuary 2025\n\t\t\t\t\tUnspecified\n\t\t\t\t\tresponse_format with json_schema\n\t\t\t\nDeepSeek\n\t\t\t\t\tAugust 2025 (Beta)\n\t\t\t\t\tUnspecified\n\t\t\t\t\tThrough strict-mode function calling\n\t\t\t\nGoogle Gemini\n\t\t\t\t\tNovember 2025\n\t\t\t\t\tUnspecified (OpenAPI 3.0 lineage)\n\t\t\t\t\tresponse_json_schema parameter\n\t\t\t\nAnthropic\n\t\t\t\t\tNovember 2025\n\t\t\t\t\t2020-12\n\t\t\t\t\toutput_config.format (and strict tool use)\n\t\t\t\nAs an interesting data point: every provider supports JSON Schema and only\nJSON Schema on the wire. Not Protocol Buffers. Not Apache Avro. Not GraphQL\nSDL. Not even Google, despite having invented Protocol\nBuffers, supports it in their own AI API.\nBut while every model now technically accepts JSON Schema, it’s not all rosy\nyet. Dialect commitment is uneven, with only xAI explicitly naming the ones\nthey support. As Ben\nHutton,\na JSON Schema Technical Steering Committee member, writes: You wouldn’t push\nyour code to a server where you didn’t know what version of the programming\nlanguage is installed. So why is this OK for JSON Schema?\nAnd even where the dialect is named, each provider supports a different slice\nof the language: there are keyword gaps, varied nested-schema depth limits, and\ndifferent limitations on advanced features. Even worse, the providers diverge\non which features they support. For example, OpenAI supports recursive schemas\nbut rejects allOf,\nwhile Anthropic does the opposite.\nThe meme has evolved. Yesterday’s pain was begging for valid JSON responses.\nToday, we beg that a valid JSON Schema is actually accepted by every provider.\nLLM output constraining is hard\nThis isn’t JSON Schema’s fault. Constraining an LLM’s output to a schema at the\ntoken level is a genuinely hard problem. Each token the model emits has to keep\nthe output valid, and supporting more of JSON Schema’s advanced features\n(logical operators, dynamic referencing and polymorphism, highly circular\nschemas, and more) makes it even harder.\nAnd this problem is complex and important enough that an entire research\nsubfield, constrained decoding, has formed\naround it.  Open-source libraries like\nOutlines (65M+ downloads),\nXGrammar, and Microsoft’s\nllguidance made the technique\npractical at production scale. There is even a published academic benchmark,\nJSONSchemaBench, built on 10,000 real-world\nJSON Schemas to evaluate competing implementations.\nAbstract of the foundational constrained-decoding paper, Efficient Guided Generation for Large Language Models, by Brandon T. Willard and Rémi Louf, who later co-founded dottxt\n  \n\nEven more, the authors of that paper went on to found\ndottxt, a French startup that raised\n$11.9M\nto solve this specific problem. Born from their popular\nOutlines library, dottxt aims for\nfull LLM JSON Schema coverage and already supports far more of JSON Schema\nthan the major providers do, allowing users to make use of JSON Schema on\narbitrary models without feeling the compatibility pain.\nWorth noting that this problem is specific to autoregressive generation. A\nnewer class of models sidesteps it entirely: non-autoregressive decision\nmodels that return a typed decision in a single forward pass instead of\ngenerating text. There is no token stream to constrain, so nothing needs a\ngrammar. And yet the contract is still JSON Schema.\nLaya, an open-weight (Apache-2.0)\nmodel of this kind, compiles “a JSON schema (or a pydantic\nmodel)”\ninto its own typed questions, accepting only a flat subset that rejects\narrays, nested objects, and $ref recursion. Even when the hard part goes\naway, JSON Schema is what a new architecture reaches for to let developers\ndeclare the shape of an answer.\nTool calling, and how MCP unified it\nLLMs are most powerful when they can connect to other systems: query databases,\nhit APIs, run computations, fetch documents. To do this they need a way to\ndeclare I want to call this function with these arguments, and every major\nprovider had to ship one. Unsurprisingly, they all landed on the same answer:\ndefine the tool’s input as JSON Schema. OpenAI’s\nparameters,\nAnthropic’s\ninput_schema,\nGemini’s\nfunction_declarations.\nDifferent field names, identical substrate.\nThen MCP (Model Context Protocol) came along\nto unify it. Announced by\nAnthropic in November\n2024 and built on JSON Schema\n2020-12, MCP is to\nAI agents what OpenAPI is to HTTP APIs: a single shared way to describe tools\nso any model can discover and invoke them. OpenAI’s official adoption in March\n2025\nwas the inflection point. Monthly SDK downloads jumped from around 8 million to\n22 million within weeks. Google DeepMind, Microsoft, Meta, Cursor, Windsurf,\nJetBrains, Replit, and ChatGPT desktop followed. In December 2025, Anthropic\ndonated MCP to the Linux Foundation, the\nsame body that governs OpenAPI and\nAsyncAPI.\nOne year of MCP: spec releases, ecosystem milestones, and adoption highlights, from the November 2024 launch to the December 2025 Linux Foundation donation. From Anthropic\n  \n\nThe adoption is substantial. By March 2026, MCP SDKs had reached 97\nmillion monthly\ndownloads,\nwith 13,700+ servers on PulseMCP\nalone and 300+ MCP clients across\neditors, chat apps, and enterprise platforms. The business case is\nconcrete. Block reports 50–75% time savings on common\ntasks for thousands of employees using their MCP-compatible\nGoose agent. Microsoft’s Sales Development\nAgent\nrecorded a 15.1% increase in lead-to-opportunity conversion across\n61,734 leads. Zapier’s MCP server connects\n9,000+ apps with 30,000+ actions.\nThe entire LLM tool ecosystem now builds on JSON Schema too.\nAnd the whole AI stack speaks JSON Schema\nBeyond the LLM APIs and the MCP/tools layer, the JSON Schema foundation\nextended naturally upward to the AI products built on top. Here is a\nnon-exhaustive list:\nRetab. Document AI platform with\n$3.5M pre-seed\nbacked by Eric Schmidt and the CEOs of Datadog and Dataiku, with\n500M+ documents processed. Their SDK literally takes a json_schema\nargument\nLandingAI. Andrew Ng’s document AI\ncompany. Their Agentic Document Extraction takes JSON Schema as\nits extraction\nformat, with\ndocumented support for standard JSON Schema keywords and format\nvalues\nVapi. Voice AI agent platform. Custom tool\ndefinitions take a JSON Schema as the parameters field\nAssemblyAI. Speech and transcript\nunderstanding. Their LLM Gateway exposes response_format with\njson_schema, OpenAI-compatible\nFirecrawl. Web scraping and\nextraction. The schema parameter takes a JSON Schema describing\nthe structured output to extract from a page\nTavily. Deep research API. The\noutput_schema parameter is “a JSON Schema object that defines\nthe structure of the research output”\nAbove the products sit agent frameworks: the libraries and tools developers\nuse to build programs that compose LLMs with tools, memory, and control flow to\ndecide for themselves which actions to take. Unsurprisingly, every major one\nuses JSON Schema as the contract between the model and the tools it can invoke:\nLangChain. The dominant Python agent\nframework\nCrewAI. Multi-agent orchestration\nOpenAI Agents SDK.\nOpenAI’s first-party agent framework\nMicrosoft Semantic\nKernel.  Microsoft’s\nframework supporting .NET, Python, and Java\nMastra. TypeScript-first agent framework\nVercel AI SDK. The dominant Next.js AI integration\nlayer\nComposio. Tool-integration platform with hundreds\nof pre-built integrations\nNone of these products coordinate on which schema language to use. They\nindependently arrived at the same answer to the same problem, making JSON\nSchema the contract at every layer of the stack.\nEven the exception isn’t quite an exception: the A2A hybrid case\nYou would expect at least one exception to this convergence. Google has every\nreason to push Protocol Buffers in their AI\ninfrastructure. So when Google designed A2A\n(Agent-to-Agent), an open protocol for AI agent-to-agent communication, they\nmade Protocol Buffers the “single authoritative normative definition” of the\nspec.\nEnd of story? Not quite. Look at how A2A actually works on the wire and JSON\nSchema is still everywhere. Agents communicate using JSON-RPC\n2.0 over HTTP. The wire format is JSON,\nnot binary Protocol Buffers. The spec already generates a JSON Schema at\nbuild time\nout of the Protocol Buffers definition, and the authors plan to add an\nOpenAPI v3 bundle on top for enhanced tooling. You can explore these schemas at\nschemas.sourcemeta.com.\nThe A2A Protocol schemas in Sourcemeta\nSchemas\n  \n\nSo even where Protocol Buffers wins as the authoring source, JSON Schema wins\nas the interoperability substrate. Charlie\nHolland captures the pattern\nprecisely: “JSON Schema becomes the ‘assembly language’ of schema\ndefinitions” and higher-level languages compile down.\nThe exception confirms the rule: convergence on JSON Schema is not just visible\nat the LLM layer. It reaches even into the protocols designed to avoid it.\nThe schema layer deserves its own infrastructure\nJSON Schema was first proposed in 2007 as a way to annotate JSON documents.\nNobody designed it for AI. It quietly became the dominant API-spec\nsubstrate over a decade and\na half. The AI industry did not pick JSON Schema. It found that JSON Schema had\nalready been picked, by seventeen years of accumulated convention, and built on\ntop. As Charlie Holland frames\nit, JSON Schema has become the interface definition language for AI tools.\nThe implication for anyone building APIs or AI-facing software is direct. Your\nschema layer is no longer documentation. It is the interface AI systems will\nuse to consume your software. And the demand for that interface is already\nuniversal. After auditing 989 Fortune 1000 companies, Kin\nLane\nfound zero without an AI signal: The signal floor is non-zero across every\nindustry in the Fortune 1000, including the ones I expected to come up empty.\nMining. Tobacco. Specialty retail.\nAnd the next layer of that interface is already taking shape: governance.\nPortkey’s review of production MCP\ndeployments catalogues the security\nand trust gaps now surfacing across the ecosystem, and points at a familiar\nmodel for closing them: A better reference is JSON-schema-based registries\nused in major cloud platforms, where structure and validation are enforced."
newsletter: "Sourcemeta Newsletter"
newsletter_handle: "sourcemeta"
newsletter_url: "https://newsletter.sourcemeta.com/"
author: "Juan Cruz Viotti (@jviotti)"
published: "2026-05-01T00:00:00.000Z"
canonical_url: "https://newsletter.sourcemeta.com/a/the-only-schema-language-ai-speaks-is-json-schema"
markdown_url: "https://newsletter.sourcemeta.com/a/the-only-schema-language-ai-speaks-is-json-schema.md"
chat_url: "https://newsletter.sourcemeta.com/a/the-only-schema-language-ai-speaks-is-json-schema/chat"
source_url: "https://www.sourcemeta.com/blog/ai-only-speaks-json-schema/"
body_source: "imported"
likes: 0
replies: 0
body_words: 2293
---

# The only schema language AI speaks is JSON Schema

> TL;DR: Every major LLM provider (OpenAI, Google, Anthropic, Mistral, xAI, DeepSeek), the Model Context Protocol, and the AI products built on them (agent frameworks and vertical AI APIs) have all converged on the same and only schema language: JSON Schema.

## AI is plumbed into APIs, and APIs speak JSON

AI is delivered through APIs. Every major LLM provider exposes its models behind an HTTP endpoint. AI also consumes the world through APIs: tool calls hit REST endpoints and [MCP servers](https://www.pulsemcp.com/servers) expose capabilities over HTTP. APIs sit on both sides of the boundary.

That observation is not contested. [Marco Palladino](https://konghq.com/blog/enterprise/what-is-an-ai-gateway), CTO of Kong, writes: *AI traffic is API traffic*. [Postman’s 2024 State of the API report](https://www.postman.com/state-of-api/2024) recorded a 73% year-over-year jump in AI-related API traffic across its platform, with OpenAI alone accounting for 78.5% of it. The [2025 follow-up](https://www.postman.com/state-of-api/2025/) puts it even more directly: *APIs are no longer just powering applications. They’re powering agents.* [Kin Lane](https://apievangelist.com/2025/01/27/how-do-i-prepare-my-apis-for-ai-agents/) treats AI agents as just another API consumer.

And those APIs speak JSON. In [Postman’s 2025 State of the API survey](https://www.postman.com/state-of-api/2025/) of 5,700+ developers, 93% reported building REST APIs, and REST APIs in practice mean JSON over HTTP.

![REST still dominates at 93% (Source: Postman 2025 State of the API)](https://www.sourcemeta.com/blog/ai-only-speaks-json-schema/api-types.webp)

*REST still dominates at 93% (Source: Postman 2025 State of the API)*

JSON is what application-layer software uses to move structured data between processes, services, and organisations. The format question was settled before LLMs arrived.

## From “please respond in valid JSON, I’m begging you” to schema-enforced generation

If AI is delivered through APIs and APIs speak JSON, then naturally users wanted LLMs to talk JSON too. In 2023, getting it reliably was a notorious engineering pain. Workarounds piled up: regex extractors, assistant prefills (`"Here is your JSON output: {"`), multi-step prompting, repair loops, and even prompts that politely *begged* the model to comply. Each had its own brittle edge cases. Charlie Guo’s [*Stop begging for JSON*](https://www.ignorance.ai/p/stop-begging-for-json) is the museum tour, and captures perfectly what anyone shipping LLM features had lived through:

![A prompt asking the LLM to return only valid JSON, followed by the model’s mocking compliance](https://www.sourcemeta.com/blog/ai-only-speaks-json-schema/meme.webp)

*A prompt asking the LLM to return only valid JSON, followed by the model’s mocking compliance*

The community treated the problem as serious enough to need dedicated infrastructure. [jsonformer](https://github.com/1rgs/jsonformer) (~5000 stars on GitHub), an open-source library released in early 2023, opened its README by saying *current approaches to this problem are brittle and error-prone*. The OpenAI developer forums in 2023–2024 were full of [similar threads](https://community.openai.com/t/gpt3-5-json-output-format/712044).

To solve this, OpenAI famously shipped the [Structured Outputs](https://openai.com/index/introducing-structured-outputs-in-the-api/) feature in August 2024: hand the API a [JSON Schema](https://json-schema.org), and the model’s output is guaranteed to validate against it at the token level. No more begging, no more retry loops, no more regex extractors. The pain went from a weekly source of suffering to an API parameter.

The choice of JSON Schema specifically wasn’t accidental. JSON Schema had been the de facto schema language for HTTP APIs for years. [OpenAPI](https://www.openapis.org), the dominant API description standard, is built on top of it. AI runs on APIs. When OpenAI needed a contract language for the JSON-output problem, they naturally reached for the one API engineers already used.

## Structured outputs: six providers, one schema language

Structured outputs proved indispensable beyond chat UIs, for any production pipeline that needed to consume LLM output programmatically. As [Julien Chaumond](https://dottxt.ai), CTO of HuggingFace, put it: *Structured generation is the future of LLMs.* Within fifteen months of the first such launch, every major LLM provider had shipped equivalent support. At the time of this writing, all of them support JSON Schema. Literally all of them:

| Provider | Launched | Dialect support | Notes |
| --- | --- | --- | --- |
| [OpenAI](https://platform.openai.com/docs/guides/structured-outputs) | August 2024 | Unspecified | `response_format` with `json_schema` |
| [xAI / Grok](https://docs.x.ai/docs/guides/structured-outputs) | December 2024 | [2020-12](https://www.learnjsonschema.com/2020-12/) and [Draft 7](https://www.learnjsonschema.com/draft7) | `response_format` with `json_schema` |
| [Mistral](https://docs.mistral.ai/capabilities/structured_output/) | January 2025 | Unspecified | `response_format` with `json_schema` |
| [DeepSeek](https://api-docs.deepseek.com/guides/function_calling) | August 2025 (Beta) | Unspecified | Through strict-mode function calling |
| [Google Gemini](https://blog.google/technology/developers/gemini-api-structured-outputs/) | November 2025 | Unspecified (OpenAPI 3.0 lineage) | `response_json_schema` parameter |
| [Anthropic](https://platform.claude.com/docs/en/build-with-claude/structured-outputs) | November 2025 | [2020-12](https://www.learnjsonschema.com/2020-12/) | `output_config.format` (and strict tool use) |

> As an interesting data point: every provider supports JSON Schema and only JSON Schema on the wire. Not Protocol Buffers. Not Apache Avro. Not GraphQL SDL. Not even Google, despite [having invented Protocol Buffers](https://protobuf.dev/), supports it in their own AI API.

But while every model now technically accepts JSON Schema, it’s not all rosy yet. Dialect commitment is uneven, with only xAI explicitly naming the ones they support. As [Ben Hutton](https://words.benhutton.me/2025-01-20-openai-chatgpt-and-structured-output-with-json-schema-pt1), a JSON Schema Technical Steering Committee member, writes: *You wouldn’t push your code to a server where you didn’t know what version of the programming language is installed. So why is this OK for JSON Schema?*

And even where the dialect is named, each provider supports a different slice of the language: there are keyword gaps, varied nested-schema depth limits, and different limitations on advanced features. Even worse, the providers diverge on which features they support. For example, OpenAI supports recursive schemas but rejects [`allOf`](https://www.learnjsonschema.com/2020-12/applicator/allof/), while Anthropic does the opposite.

The meme has evolved. Yesterday’s pain was begging for valid JSON responses. Today, we beg that a valid JSON Schema is actually accepted by every provider.

## LLM output constraining is hard

This isn’t JSON Schema’s fault. Constraining an LLM’s output to a schema at the token level is a genuinely hard problem. Each token the model emits has to keep the output valid, and supporting more of JSON Schema’s advanced features (logical operators, dynamic referencing and polymorphism, highly circular schemas, and more) makes it even harder.

And this problem is complex and important enough that an entire research subfield, [constrained decoding](https://arxiv.org/abs/2307.09702), has formed around it. Open-source libraries like [Outlines](https://github.com/dottxt-ai/outlines) (65M+ downloads), [XGrammar](https://github.com/mlc-ai/xgrammar), and Microsoft’s [llguidance](https://github.com/guidance-ai/llguidance) made the technique practical at production scale. There is even a published academic benchmark, [JSONSchemaBench](https://arxiv.org/pdf/2501.10868), built on 10,000 real-world JSON Schemas to evaluate competing implementations.

![Abstract of the foundational constrained-decoding paper, Efficient Guided Generation for Large Language Models, by Brandon T. Willard and Rémi Louf, who later co-founded dottxt](https://www.sourcemeta.com/blog/ai-only-speaks-json-schema/paper.webp)

*Abstract of the foundational constrained-decoding paper, *Efficient Guided Generation for Large Language Models*, by Brandon T. Willard and Rémi Louf, who later co-founded dottxt*

Even more, the authors of that paper went on to found [dottxt](https://dottxt.ai), a French startup that [raised $11.9M](https://techfundingnews.com/french-startup-dottxt-raises-11-9m-to-tell-how-ai-models-answer/) to solve this specific problem. Born from their popular [Outlines](https://github.com/dottxt-ai/outlines) library, dottxt aims for full LLM JSON Schema coverage and already supports far more of JSON Schema than the major providers do, allowing users to make use of JSON Schema on arbitrary models without feeling the compatibility pain.

Worth noting that this problem is specific to autoregressive generation. A newer class of models sidesteps it entirely: non-autoregressive *decision* models that return a typed decision in a single forward pass instead of generating text. There is no token stream to constrain, so nothing needs a grammar. And yet the contract is still JSON Schema. [Laya](https://github.com/NandhaKishorM/laya), an open-weight (Apache-2.0) model of this kind, compiles [*“a JSON schema (or a pydantic model)”*](https://github.com/NandhaKishorM/laya/blob/4aa6761be8173de4ce6d92c31b3e40b6eaf59a7c/laya/structured.py) into its own typed questions, accepting only a flat subset that rejects arrays, nested objects, and `$ref` recursion. Even when the hard part goes away, JSON Schema is what a new architecture reaches for to let developers declare the shape of an answer.

## Tool calling, and how MCP unified it

LLMs are most powerful when they can connect to other systems: query databases, hit APIs, run computations, fetch documents. To do this they need a way to declare *I want to call this function with these arguments*, and every major provider had to ship one. Unsurprisingly, they all landed on the same answer: define the tool’s input as JSON Schema. OpenAI’s [`parameters`](https://platform.openai.com/docs/guides/function-calling), Anthropic’s [`input_schema`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools), Gemini’s [`function_declarations`](https://ai.google.dev/gemini-api/docs/function-calling). Different field names, identical substrate.

Then [MCP](https://modelcontextprotocol.io) (Model Context Protocol) came along to unify it. [Announced by Anthropic](https://www.anthropic.com/news/model-context-protocol) in November 2024 and [built on JSON Schema 2020-12](https://modelcontextprotocol.io/specification/2025-11-25), MCP is to AI agents what OpenAPI is to HTTP APIs: a single shared way to describe tools so any model can discover and invoke them. [OpenAI’s official adoption in March 2025](https://techcrunch.com/2025/03/26/openai-adopts-rival-anthropics-standard-for-connecting-ai-models-to-data/) was the inflection point. Monthly SDK downloads jumped from around 8 million to 22 million within weeks. Google DeepMind, Microsoft, Meta, Cursor, Windsurf, JetBrains, Replit, and ChatGPT desktop followed. In December 2025, Anthropic donated MCP to the [Linux Foundation](https://www.linuxfoundation.org), the same body that governs [OpenAPI](https://www.openapis.org) and [AsyncAPI](https://www.asyncapi.com).

![One year of MCP: spec releases, ecosystem milestones, and adoption highlights, from the November 2024 launch to the December 2025 Linux Foundation donation. From Anthropic](https://www.sourcemeta.com/blog/ai-only-speaks-json-schema/mcp-timeline.webp)

*One year of MCP: spec releases, ecosystem milestones, and adoption highlights, from the November 2024 launch to the December 2025 Linux Foundation donation. From [Anthropic](https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation)*

The adoption is substantial. By March 2026, MCP SDKs had reached [97 million monthly downloads](https://effloow.com/articles/mcp-ecosystem-growth-100-million-installs-2026), with [13,700+ servers on PulseMCP alone](https://www.pulsemcp.com/servers) and 300+ MCP clients across editors, chat apps, and enterprise platforms. The business case is concrete. [Block](https://block.xyz/) reports 50–75% time savings on common tasks for thousands of employees using their MCP-compatible [Goose](https://block.github.io/goose/) agent. [Microsoft’s Sales Development Agent](https://www.microsoft.com/en-us/dynamics-365/blog/business-leader/2025/11/18/microsoft-ignite-2025-powering-frontier-firms-with-agentic-business-applications/) recorded a 15.1% increase in lead-to-opportunity conversion across 61,734 leads. [Zapier’s MCP server](https://zapier.com/mcp) connects 9,000+ apps with 30,000+ actions.

The entire LLM tool ecosystem now builds on JSON Schema too.

## And the whole AI stack speaks JSON Schema

Beyond the LLM APIs and the MCP/tools layer, the JSON Schema foundation extended naturally upward to the AI products built on top. Here is a non-exhaustive list:

- **[Retab](https://www.retab.com)**. Document AI platform with [$3.5M pre-seed](https://www.startuphub.ai/ai-news/funding-round/2025/retab-exits-stealth-mode-with-3-5m-for-sota-ai-document-processing/) backed by Eric Schmidt and the CEOs of Datadog and Dataiku, with 500M+ documents processed. Their SDK literally takes a `json_schema` argument
- **[LandingAI](https://landing.ai)**. Andrew Ng’s document AI company. Their Agentic Document Extraction takes [JSON Schema as its extraction format](https://docs.landing.ai/ade/ade-extract-schema-json), with documented support for standard JSON Schema keywords and format values
- **[Vapi](https://vapi.ai)**. Voice AI agent platform. Custom tool definitions take a JSON Schema as the `parameters` field
- **[AssemblyAI](https://www.assemblyai.com)**. Speech and transcript understanding. Their LLM Gateway exposes `response_format` with `json_schema`, OpenAI-compatible
- **[Firecrawl](https://www.firecrawl.dev)**. Web scraping and extraction. The `schema` parameter takes a JSON Schema describing the structured output to extract from a page
- **[Tavily](https://tavily.com)**. Deep research API. The `output_schema` parameter is *“a JSON Schema object that defines the structure of the research output”*

Above the products sit *agent frameworks*: the libraries and tools developers use to build programs that compose LLMs with tools, memory, and control flow to decide for themselves which actions to take. Unsurprisingly, every major one uses JSON Schema as the contract between the model and the tools it can invoke:

- **[LangChain](https://www.langchain.com)**. The dominant Python agent framework
- **[CrewAI](https://www.crewai.com)**. Multi-agent orchestration
- **[OpenAI Agents SDK](https://openai.github.io/openai-agents-python/)**. OpenAI’s first-party agent framework
- **[Microsoft Semantic Kernel](https://learn.microsoft.com/semantic-kernel/)**. Microsoft’s framework supporting .NET, Python, and Java
- **[Mastra](https://mastra.ai)**. TypeScript-first agent framework
- **[Vercel AI SDK](https://ai-sdk.dev)**. The dominant Next.js AI integration layer
- **[Composio](https://composio.dev)**. Tool-integration platform with hundreds of pre-built integrations

None of these products coordinate on which schema language to use. They independently arrived at the same answer to the same problem, making JSON Schema the contract at every layer of the stack.

## Even the exception isn’t quite an exception: the A2A hybrid case

You would expect at least one exception to this convergence. Google has every reason to push [Protocol Buffers](https://protobuf.dev/) in their AI infrastructure. So when Google designed [A2A](https://a2a-protocol.org/) (Agent-to-Agent), an open protocol for AI agent-to-agent communication, they made Protocol Buffers the *“single authoritative normative definition”* of the spec.

End of story? Not quite. Look at how A2A actually works on the wire and JSON Schema is still everywhere. Agents communicate using [JSON-RPC 2.0](https://www.jsonrpc.org/specification) over HTTP. The wire format is JSON, not binary Protocol Buffers. The spec already [generates a JSON Schema at build time](https://github.com/a2aproject/A2A/blob/v1.0.0/scripts/proto_to_json_schema.sh) out of the Protocol Buffers definition, and the authors plan to add an OpenAPI v3 bundle on top for enhanced tooling. You can explore these schemas at [schemas.sourcemeta.com](https://schemas.sourcemeta.com/a2a).

![The A2A Protocol schemas in Sourcemeta](https://www.sourcemeta.com/blog/ai-only-speaks-json-schema/a2a-schemas.webp)

*The A2A Protocol schemas in [Sourcemeta Schemas](https://schemas.sourcemeta.com/a2a)*

So even where Protocol Buffers wins as the authoring source, JSON Schema wins as the interoperability substrate. [Charlie Holland](https://www.chiply.dev/post-schema-languages) captures the pattern precisely: *“JSON Schema becomes the ‘assembly language’ of schema definitions”* and higher-level languages compile down.

The exception confirms the rule: convergence on JSON Schema is not just visible at the LLM layer. It reaches even into the protocols designed to avoid it.

## The schema layer deserves its own infrastructure

JSON Schema was first proposed in 2007 as a way to annotate JSON documents. Nobody designed it for AI. It quietly became the [dominant API-spec substrate](https://www.sourcemeta.com/blog/json-schema-dominates-openapi/) over a decade and a half. The AI industry did not pick JSON Schema. It found that JSON Schema had already been picked, by seventeen years of accumulated convention, and built on top. As [Charlie Holland](https://www.chiply.dev/post-schema-languages) frames it, JSON Schema has become *the interface definition language for AI tools*.

The implication for anyone building APIs or AI-facing software is direct. Your schema layer is no longer documentation. It is the interface AI systems will use to consume your software. And the demand for that interface is already universal. After auditing 989 Fortune 1000 companies, [Kin Lane](https://apievangelist.com/blog/2026/05/25/the-fortune-1000-is-saturated-with-ai/) found zero without an AI signal: *The signal floor is non-zero across every industry in the Fortune 1000, including the ones I expected to come up empty. Mining. Tobacco. Specialty retail.*

And the next layer of that interface is already taking shape: governance. [Portkey’s review of production MCP deployments](https://portkey.ai/blog/mcp-governance/) catalogues the security and trust gaps now surfacing across the ecosystem, and points at a familiar model for closing them: *A better reference is JSON-schema-based registries used in major cloud platforms, where structure and validation are enforced.*

***

## Discussion

No replies yet.
