Google Just Open-Sourced Its SDK Generator What the Speakeasy Deal Means for Your API Pipeline

The Hidden Risk in Your SDK Pipeline

Every API-first company eventually faces the same problem: you define your interface in OpenAPI, but turning that spec into clean, idiomatic client libraries across Python, TypeScript, Go, and Java is a different beast. Streaming protocols, strict error hierarchies, rich type unions — handcrafted generators or proprietary tools handle this, but they also lock you in.

That lock-in became a real crisis for Google's GenAI team. In May 2026, their SDK generation vendor was acquired and shut down overnight, right before Google I/O and the GA launch of the Interactions API. The lesson: if OpenAPI is the interface standard, the compiler that turns specs into SDKs should be open infrastructure.

This is the context behind Google's partnership with Speakeasy to open-source their full OpenAPI client suite under AGPLv3. For any team shipping SDKs, this is a signal that the tooling layer is finally catching up to the spec layer.

What Actually Changed (and the Code)

The headline is licensing, but the engineering story matters more. Google migrated their existing client libraries in place, preserving strict error hierarchies and streaming behavior across six targets — with roughly one engineer maintaining what used to require a team.

Here's what the new Gemini Interactions SDK looks like in practice:

# Install: pip install google-genai
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="Analyze this commit log and find regressions.",
)

print(interaction.output_text)

The key architectural decision: deterministic generation at the core, AI agents for the custom parts. Google uses Speakeasy's deterministic generator for the formal spec-to-SDK transformation, then Antigravity AI agents to accelerate bespoke logic. This is the right split — you don't want an LLM hallucinating your type definitions.

To generate your own client libraries, CLIs, or MCP servers, run the Speakeasy generator against your OpenAPI spec:

# Clone the open-source generator
 git clone https://github.com/speakeasy-api/speakeasy

# Generate a TypeScript SDK from your spec
speakeasy generate sdk \
  --schema ./openapi.yaml \
  --lang typescript \
  --out ./sdk

The AGPLv3 license is the important nuance: your generated code stays yours (MIT, Apache 2.0, whatever you choose). Only modifications to the generator compiler itself must remain open. That's a fair trade for infrastructure-level tooling.

The Trade-offs You Should Actually Care About

Limitations and Caveats

• AGPLv3 is not for everyone. If you plan to modify the generator itself and offer it as a hosted service, the copyleft obligations kick in. Most teams only consume the generator, so this rarely bites — but read the license before you fork.
• Determinism != correctness. A deterministic generator produces the same output every time, but if your OpenAPI spec is wrong, you'll get consistently wrong SDKs. Invest in spec linting (Spectral, Redocly) before blaming the generator.
• Migration is not free. Google had a tight timeline and internal monorepo integration. If you're switching generators mid-flight, budget for type alignment across languages — this is where most of the engineering hours go.

Next Steps for Your Team

1. Audit your current SDK generation for vendor lock-in — who owns the tool, and what happens if they disappear?
2. Try Speakeasy against a small OpenAPI spec in a throwaway repo before committing.
3. If you maintain MCP servers or CLIs, this generator gives you a fast path to multi-language tooling from a single spec.

For a deeper look at how open-source model releases are reshaping the AI tooling layer, check out IBM Granite Embedding Multilingual R2 — another case of open infrastructure winning on merit.

The Bigger Picture

Google's move isn't just about one SDK generator. It's a public acknowledgment that the tooling layer around OpenAPI is too important to be proprietary. When a vendor acquisition can derail a GA launch, the ecosystem has a structural problem.

The AGPLv3 choice is pragmatic: it keeps the generator open while letting companies keep their generated code. That's the right balance for infrastructure. And the fact that one engineer now maintains six SDK targets is the real headline — that's the productivity gain that makes open-source tooling sustainable.

If you're building an API-first product, this is your cue to treat SDK generation as infrastructure, not a vendor contract. Start with the Speakeasy generator on GitHub and run it against your spec this week. The barrier to entry just dropped to zero.

Further reading: Claude Sonnet 5.5 Lands on Vercel AI Gateway — another example of how the AI tooling stack is consolidating around open gateways.