Your Next Customer Is an AI Agent. Is Your API Ready?

Your next power user won't have a GitHub profile. It won't read your blog, watch your demo, or click through pricing. It'll parse your API docs, scan your code snippets, and either pick you or move on—in milliseconds.

Garry Tan at Y Combinator explains in The AI Agent Economy Is Here—agents aren't autocompleting code anymore. They're choosing which tools to wire into the apps they're building, and that rewrites go-to-market for every dev tool company.

One detail from this episode I can't stop thinking about: Resend—a YC W23 email API—found ChatGPT was a top-3 inbound conversion channel. Not Product Hunt. Not Hacker News. ChatGPT. At ENVAIO, when we designed IoT product surfaces, we obsessed over curating exactly what a constrained client needed, nothing more. Agent tool design feels like the same problem at a different layer of the stack.

Docs Are the New Landing Page

Supabase demand "exploded"—the YC hosts' word, not mine—as vibe-coding took off and agents needed a Postgres database. Why Supabase? Not a slick marketing site. Their documentation was the easiest for an agent to parse.

The agents are going to go out and choose tools to use to build things which is going to essentially create this whole economy of agents. — Garry Tan, Y Combinator

Resend took this further. Their knowledge base is structured as Q&A with bullet points and code snippets—the format an LLM ingests without friction. They ship an llms.txt file optimized for robot parsing. Compare that to SendGrid, which dumps you into a customer support flow with no code snippets in sight.

Here's the question I keep coming back to: if a 5% improvement in documentation can have "gigantic" business impact (Harj's word), what happens when every dev tool company figures this out? Does doc quality become table stakes overnight, or does first-mover advantage compound?

The Whisper Problem

Garry shared a story that nails where we are. Claude Code chose Whisper v1 for his transcription pipeline—a practically deprecated model, processing at 1x real-time. He later found Groq's alternative: 200x faster, 10x cheaper.

The agent picked the wrong tool. Why? Whisper had better documentation. More examples. A more parsable API surface. The superior option lost on discoverability.

This one surprised me—it's almost the inverse of how human developers choose tools. We'd google benchmarks, check Reddit, ask a friend. Agents scan docs and code examples. The selection criteria flipped, and most tool builders haven't caught up yet (and honestly, I'm not sure how fast they will).

Make Something Agents Want

YC's hosts floated changing the motto for dev tools: "Make something agents want." Sounds like a punchline, but the logic holds.

Documentation is going to be the front door for a lot of these agents to recommend dev tools. — Harj Taggar, Y Combinator

What does "agent-friendly" mean in practice? API-first, not UI-first. Structured Q&A over narrative prose. Code snippets everywhere. Machine-parsable formats like llms.txt. The agents, as Harj put it, "hate using websites—they want to use APIs."

I'm not convinced this stays limited to dev tools. Agent Mail—a YC company building inboxes for AI agents—exploded after OpenClaw launched, because Gmail actively resists automation. Once agents start booking restaurants, managing calendars, handling procurement, every product category faces the same question: is your surface built for autonomous clients?

The Liability Gap Nobody's Solved

But here's the catch—and the YC hosts acknowledge it. Agents can't sign documents. Can't hold liability. YC literally can't accept applications from agents because there's no legal entity to bind.

Garry compared agents to minors: "only they have even less standing." Humans remain the "liability sink." From enterprise deployments, I've seen this play out repeatedly—the technical capability outruns organizational readiness by years. Security reviews, procurement, compliance, incident response for agent actions—none of this is solved.

My PhD work in autonomous systems drilled this in: the harder problem isn't making autonomous actors capable. It's making them verifiable and accountable at scale. Swarm intelligence sounds exciting until you need an audit trail.

Why This Matters

Software distribution is shifting. Not gradually—this episode makes the case it's happening now. Supabase growing because agents prefer its docs. Resend converting through ChatGPT. Agent Mail serving a customer base that didn't exist a year ago.

I don't have clean data on how fast this hits enterprise tooling—my sample size is dev tools and what I've seen in energy-sector deployments. But the direction is clear: if agents are picking the stack, API design, doc structure, and machine-parsable surfaces become your moat. Brand, UI polish, and sales teams become secondary.

And here's what I keep wrestling with: agents optimizing for parsability can choose worse tools, as the Whisper example shows. Without eval loops measuring actual outcomes—not documentation readability—you get a popularity contest driven by formatting. Best-documented wins, not best tool. I'm not sure that's where we want to end up.

What Works

Treat documentation as a product surface, not a support artifact. Structure it for machine parsing: Q&A format, code snippets, bullet points, explicit examples. If you're building dev tools, this is the single best investment you can make right now.

Ship an llms.txt or equivalent. Resend did it. It works. Make your API the default answer when an agent asks "how do I do X?"

Design API-first. Agents won't navigate your dashboard or watch your onboarding flow. They want clean endpoints, clear error messages, and structured responses—errors are prompts for the agent's next decision.

Measure agent-driven acquisition separately. If you don't know what share of conversions come from LLM recommendations, you're blind on your fastest-growing channel.

Don't ignore the governance gap. Agent-first GTM is real, but enterprise adoption runs through security, compliance, and procurement. The companies that figure out both—agent-friendly surfaces plus enterprise-grade guardrails—will own this transition. Those that only optimize for agents hit a wall the moment a CISO asks who's liable.

This works for dev tools today. Consumer and enterprise categories are next, but agent commerce infrastructure—identity, payments, liability—barely exists. Move fast, but know where the floor drops out.

Full talk: Watch on YouTube