← Blog
#AI#MCP#SDK#Anthropic#developer-tools

Anthropic Acquires Stainless: What It Means for SDK and MCP Development

webhani·

What Stainless Does

Founded in 2022 by a former Stripe engineer, Stainless builds tooling that generates production-quality SDKs from an API specification. TypeScript, Python, Go, Java, Kotlin — one spec, consistent output across all languages.

The customer list is what makes this acquisition significant: OpenAI, Google, and Cloudflare all used Stainless alongside Anthropic. Shared infrastructure among competing AI labs is now being pulled under one roof. Anthropic reportedly paid north of $300 million for the company, according to reporting by The Information and covered by TechCrunch on May 18, 2026.

Why This Matters

SDK quality drives API adoption. An SDK that handles retries, pagination, type-safe errors, and streaming correctly removes friction from the developer's first day with an API. Stainless specialized in this — and now Anthropic owns that capability outright.

The MCP angle is strategic. Stainless didn't just generate SDKs. It also generated MCP (Model Context Protocol) servers — the connectors that let AI agents interact with external tools. Anthropic created MCP and has been pushing it as a standard. Bringing the primary MCP server generator in-house strengthens that position considerably.

Competitors lose a shared resource. Anthropic is shutting down Stainless's hosted SDK generator service. Existing customers retain full rights to code they've already generated, but the generator itself is gone. OpenAI and Google need to find alternatives.

The SDK Quality Gap

Here's a concrete example of what high-quality SDK generation looks like in practice:

# Without a generated SDK: manual HTTP with incomplete error handling
import httpx
 
response = httpx.post(
    "https://api.anthropic.com/v1/messages",
    headers={"x-api-key": api_key, "anthropic-version": "2023-06-01"},
    json={"model": "claude-opus-4-7", "max_tokens": 1024, "messages": [...]},
)
if response.status_code != 200:
    raise Exception(f"Error {response.status_code}: {response.text}")
data = response.json()
 
# With the generated SDK: typed, retry-aware, streaming-ready
from anthropic import Anthropic
 
client = Anthropic()
message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}],
)
print(message.content[0].text)

The difference isn't just ergonomics. The generated SDK handles exponential backoff, rate limit headers, streaming response reassembly, and typed error classification. Writing this consistently across six languages is exactly what Stainless automated.

MCP Server Generation

The MCP server generation capability is where things get interesting for developers building agent workflows. A basic MCP server requires significant boilerplate:

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
 
const server = new Server(
  { name: "my-api-server", version: "1.0.0" },
  { capabilities: { tools: {} } }
);
 
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "get_data",
      description: "Retrieve data by ID",
      inputSchema: {
        type: "object",
        properties: { id: { type: "string" } },
        required: ["id"],
      },
    },
  ],
}));
 
// ... request handler, transport setup, error handling

Stainless generated all of this from your OpenAPI spec. With the hosted generator gone, teams building new MCP servers from API specs need to either write this manually or evaluate alternatives. Current options include Speakeasy and Fern, though neither has the same MCP-specific focus that Stainless had been developing.

What Developers Should Do Now

If you're already using Stainless-generated SDKs: No action required. Your generated code is yours permanently. When you need to extend it, you can modify it directly or script your own generation on top of your API spec.

If you're starting a new project that needs multi-language SDKs: Evaluate Speakeasy, Fern, and the option of maintaining SDK templates in-house. The market will move to fill the gap Stainless is leaving.

If you're building MCP servers: Get comfortable with the MCP SDK directly. Given Anthropic's ownership of both MCP and now the leading MCP generation tooling, first-party MCP tooling improvements are likely over the next 12 months.

If you use Anthropic's official SDKs: No disruption expected. Anthropic will maintain and improve these in-house. SDK quality is more likely to improve than degrade.

Takeaway

The Stainless acquisition is a bet that developer experience infrastructure — SDKs, CLIs, MCP connectors — is as strategically important as model performance. Anthropic is moving toward controlling the full stack of how developers interact with its API.

For teams building on the Anthropic platform, this likely means better SDK quality over time. For teams that relied on Stainless for other providers, it's time to plan a migration. The broader signal is that AI competition in 2026 isn't just about benchmark scores — it's about who owns the developer experience layer.

← Back to Blog