a16z Podcast – "Building APIs for Developers and AI Agents"
Host: Andreessen Horowitz
Guests: Alex Rattrade (Founder, Stainless), Jennifer Lee (Partner, a16z)
Date: September 6, 2025

Episode Overview

This episode explores the evolving landscape of APIs, focusing on how developer and AI agent experiences are converging. Alex Rattrade, founder of Stainless, and a16z’s Jennifer Lee discuss APIs as critical infrastructure, the increasing importance of robust SDKs and documentation, and the new design challenges brought by AI agents as first-class API users. The conversation delves into lessons from Stripe, how Stainless is building tools for modern API platforms, the concept of MCP (model-completion protocol) for AI agents, and the future of developer and "agent" experiences.

Key Discussion Points & Insights

1. APIs as the "Dendrites" of the Internet

• Alex compares APIs to brain dendrites, emphasizing their critical role as the connectors of internet software.

"APIs are the dendrites of the Internet... that synapse is almost always an API of some kind."
— Alex Rattrade [00:00], [07:03]

• APIs are the primary way software "thinks" and "acts" by interacting with other programs.

2. The Importance—and Difficulty—of Great SDKs

• At Stripe, Alex saw that for developers, the SDK is the API, making language-idiomatic, robust SDKs crucial.

"To developers who use the Stripe API every day, the SDK is the API."
— Alex Rattrade [01:49]

• OpenAPI generators often fail to meet high quality standards.

"The maintenance burden, the headaches involved... it's just too much for almost any company other than, you know, something like a Stripe at 2,000 people..."
— Alex Rattrade [01:49]

• Stainless aims to bring "Stripe-level" developer platforms to all API companies, with well-typed SDKs and excellent docs.

3. Engineering Robust, Idiomatic SDKs

• Creating SDKs requires deep attention to language idioms, documentation, error handling, telemetry, and evolving standards (e.g., Python typing, async).

"An SDK also needs to be really polished... if you're building something for a Python developer, that it's idiomatic to them."
— Alex Rattrade [04:25]

4. Introducing MCP: APIs for LLMs and AI Agents

• MCP reframes the question: what’s idiomatic and ergonomic for an LLM, not a human developer?
• The field is inventing best practices for exposing APIs to LLM agents.

"Instead of exposing your API to a Python developer... with MCP you expose your API to an LLM agent."
— Alex Rattrade [04:25]

5. Design Challenges for AI Agents

• Main pain points:
  • Context Window Limits: Exposing too many API endpoints/parameters overwhelms LLMs.
  • Tool Overload: Need mechanisms to present APIs dynamically and selectively.
• Stainless offers dynamic tool exposure, O(1) tool pattern, and JQ filtering for API responses, enabling LLMs to focus on relevant contexts.

"If you want to describe every single endpoint... you've just used up your entire context window. And that basically just doesn't work."
— Alex Rattrade [10:02] "What we've done is we've added sort of this JQ filter to all of these requests."
— Alex Rattrade [13:08]

6. The Continuing Importance of Strong SDKs and Docs

• The proliferation of AI agents raises, not lowers, the bar for SDK quality.
• LLMs often prefer using SDKs because type checking prevents mistakes.

"For any company that ships an API... it's really critical to make it easy for people to move fast at that integration so that it can happen before some other project comes in and for them to do that with confidence."
— Alex Rattrade [20:07] "It’s important to note that the agent preferred to use the SDK... With the SDK you have type checking."
— Alex Rattrade [16:57]

7. The Future: Developer and Agent Experience

• APIs should grow more declarative, dry, and reviewable for code written by both humans and agents.
• There will be higher standards and more prescriptive API design conventions for consistency and LLM usability.
• Tools and frameworks will absorb the "boring" details (e.g., error handling), enabling developers to focus on high-level tasks.

"For people building APIs, you want a way to write your backend code that is going to be not like spaghetti."
— Alex Rattrade [21:33] "The humans should be thinking about... the high levels of what the business needs and letting the robots do all the less exciting stuff."
— Alex Rattrade [23:26]

8. API Platform Learnings from Leading Companies

• Across companies like OpenAI, Anthropic, Cloudflare, core lessons repeat: prioritize exposing core capabilities cleanly, be thoughtful about user needs, and abstract away infrastructure headaches.

"Everyone in this space sees how important it is to be thoughtful, how important it is to consider the user..."
— Alex Rattrade [24:45]

Notable Quotes & Memorable Moments

• "APIs are the dendrites of the Internet... that synapse is almost always an API." — Alex Rattrade [00:00], [07:03]
• "To developers who use the Stripe API every day, the SDK is the API." — Alex Rattrade [01:49]
• "The industry spent years basically figuring out how to make an idiomatic Python library." — Alex Rattrade [04:25]
• "MCP is this kind of new frontier... what's intuitive to an LLM, what is usable and ergonomic and idiomatic to a large language model?" — Alex Rattrade [04:25]
• "You've just used up your entire context window. And that basically just doesn't work." — Alex Rattrade [10:02]
• "LLMs are great at JQ, so just giving them that tool has enabled them to say, out of this large API request, I only need Jennifer's name and email and description..." — Alex Rattrade [13:08]
• "It’s important to note that the agent preferred to use the SDK... With the SDK you have type checking." — Alex Rattrade [16:57]
• "The humans should be thinking about... the high levels of what the business needs and letting the robots do all the less exciting stuff." — Alex Rattrade [23:26]

Timestamps for Key Segments

| Timestamp | Segment | |-----------|---------------------------------------------------------------------------------------------| | 00:00 | APIs as the “dendrites” of the Internet; foundational role | | 01:49 | Stripe API platform experience; birth of Stainless | | 04:25 | Challenges and craftsmanship in SDK generation; idiomatic language support | | 06:46 | APIs, MCP, and the biological metaphor for AI interfaces | | 10:02 | Design problems: context windows, tool overload for LLMs | | 13:08 | Stainless’s solutions: dynamic tools, JQ filtering for API responses | | 16:57 | Why more usage means even greater need for type-safe SDKs and docs | | 20:54 | The future: Designing for agents and humans, declarative and reviewable code | | 24:45 | Lessons from leading API teams; prioritizing user-focused, capability-first API platforms |

Takeaways

• APIs are no longer just for human developers: LLM agents are new "users," and platforms must serve both.
• SDKs remain vital: Strong, idiomatic SDKs with comprehensive docs support both accuracy and velocity for both humans and agents.
• AI brings new design frontiers: Handling context window limits, dynamic interface exposure, and response filtering is crucial as agents become more sophisticated.
• Abstraction and automation rise: The next-gen API platforms will let humans focus on high-level design and business value, while codegen and frameworks handle the complexity.
• Universal lessons: The best API teams continuously revisit clarity, user-centric design, and abstraction of infrastructure, regardless of their audience.

This episode delivers a dense, insightful roadmap for anyone building, maintaining, or consuming APIs in the age of AI agents.