Business considerations in the wake of the Stainless acquisition.

What changes for companies that use and build MCPs, and where the differentiation moves next.

The real asset is the generator, not the customer list.

Stainless is a code-generation pipeline: feed it an OpenAPI spec, and it emits idiomatic SDKs in multiple languages plus, more recently, MCP servers.

  • Same plumbing Anthropic was already using to ship Claude libraries; the same plumbing OpenAI and Google used for theirs.
  • The acquisition gives Anthropic ownership of a factory that converts API definitions into agent-ready interfaces at scale.
  • That is the strategic asset. The logos on the customer page are secondary.

MCP server creation is about to be commoditized.

If a product strategy rests on "we will build a really good MCP server," that moat just got shallower.

  • Spec-to-MCP becomes push-button. Expect the capability to land inside Claude's developer platform within months, likely free or near-free for Claude-compatible integrations.
  • The existence of an MCP server stops being a differentiator.
  • Quality, scope, and semantics of what gets exposed become the entire game.
The shift

"Has an MCP server" was the signal enterprise buyers looked for. "Has a well-designed MCP server" is the next one.

The OpenAPI spec becomes a strategic asset.

When generation is cheap, the upstream artifact decides everything. Sloppy spec produces sloppy MCP server, which produces agent misuse.

  • Clean schemas, semantic naming, rich descriptions, real examples, explicit error semantics.
  • APIs already well-designed for human developers will get great MCP servers nearly for free.
  • Crufty internal APIs need real work before automation pays off.
Where to invest now

API hygiene. The companies that funded it before this acquisition will look prescient inside a year.

Generate now. Curate later.

For SaaS products competitors have not yet wrapped in MCP, there is a short window where shipping any MCP server signals "agent-ready" to enterprise buyers.

  • Use Stainless-style generation (or its successors). Do not hand-craft a server that gets thrown away in six months.
  • Prioritize coverage of the highest-value workflows. Breadth comes later.
  • Design around tasks an agent actually wants to accomplish, not a 1:1 mirror of REST endpoints.
Caution

Generated MCP servers tend to mirror APIs literally. Literal mirrors are almost always bad agent interfaces. The generation step still needs an editor.

For internal apps: expose, don't rebuild.

Many enterprises have been debating whether to build agent-specific microservices or expose existing internal APIs via MCP. Cheap generation tilts the answer.

  • The marginal cost of exposing an existing service drops dramatically.
  • The hard problems shift to which capabilities to expose, auth and permissioning at the tool-call boundary, and observability of what agents actually do once they have hands on production systems.
  • The SDK code is no longer where the strategic work lives.

Lock-in risk is real and worth pricing in.

Anthropic now owns the generator that produced OpenAI's and Google's SDKs. The protocol is open; the tooling around it is consolidating.

  • Hosted-product access for rivals has reportedly already started narrowing.
  • An MCP strategy built entirely on Anthropic-owned generation is a bet on Anthropic's continued goodwill and pricing.
  • Mitigation: keep OpenAPI specs canonical and portable; treat the generated MCP server as disposable output; preserve the ability to re-generate against open-source alternatives like FastMCP if terms change.

Surface area beats model capability.

The bottleneck for useful agents is no longer how smart the model is. It is the set of tools agents can reliably reach.

  • In 12 to 24 months, the question stops being "is the product AI-enabled?"
  • It becomes: can an agent operating on a customer's behalf accomplish a meaningful task in this product without human intervention?
  • If the answer is no, the product is invisible to the agent layer.

MCP generation is becoming infrastructure. Differentiation moves up the stack.

Differentiation moves up the stack.

Five shifts worth tracking now that the generation layer is becoming infrastructure.

  1. Spec quality. OpenAPI specs treated as product-grade artifacts: descriptions, examples, error semantics, semantic naming.
  2. Task-shaped tooling. MCP tools designed around the five to ten highest-value agent tasks, not blind endpoint mirrors.
  3. Auth and observability at the tool boundary. Logging and permissioning for what agents actually do once they reach production systems.
  4. Explicit ecosystem positioning. Anthropic-bet, protocol-neutral, or multi-homed; budgeted accordingly.
  5. Agent task completion rate. A product KPI for the agent layer. The metric this whole shift is converging toward.