Executive Overview
In 2021, Twilio CEO Jeff Lawson published Ask Your Developer, a book that captured a seismic shift in enterprise technology. Lawson’s thesis was straightforward yet revolutionary: software buying power had shifted away from traditional IT executives and top-down procurement committees. Instead, it rested firmly in the hands of software engineers. If a B2B infrastructure company wanted to win a lucrative deal, it had to win over the engineer—because the engineer brought the budget with them.
Fast-forward five years. A parallel transformation is taking place, one layer deeper down the technology stack. We have officially moved past the era of human-led developer procurement and entered the age of Agent-Led Growth (ALG).
Today, autonomous and semi-autonomous AI agents are no longer just productivity assistants sitting in sidebars; they are active, operational decision-makers. They evaluate infrastructure, negotiate pricing models, execute vendor selections, monitor software performance, and—crucially—terminate contracts with zero emotional friction or human hesitation.
At SaaStr, our internal operations provide a vivid window into this new paradigm. We currently run upwards of 21 specialized AI agents in production, supported by a lean team of just three humans. An increasingly massive share of our vendor selection process starts with a question posed to an agent, and a growing percentage ends there entirely. Our agents have demonstrated the capacity to pick vendors, kill legacy software contracts, consolidate redundant tools, and advise us to skip purchasing entirely in favor of native builds.
For B2B software founders, venture capitalists, and go-to-market (GTM) leaders, this shift changes everything. Search Engine Optimization (SEO), Answer Engine Optimization (AEO), and Generative Engine Optimization (GEO)—tactics engineered to manipulate how a human query gets answered by ChatGPT or Claude—are no longer enough. Agents operate with context that conversational chat models can only dream of: they see your entire application stack, internal data flows, historical usage volumes, real-time telemetry, and exact cost structures.
If your software product is invisible to the internal agentic workflows running inside modern enterprises, you aren’t just losing deals—you are missing the entire conversation before it ever reaches a human desk.
Detailed Chronology: How SaaStr’s Stack Was Overhauled by Agents
To understand the practical mechanics of Agent-Led Growth, one must look at how decisions are actually made on the ground. Over the past few months, SaaStr’s internal deployment of agents—specifically our lead operational agent, colloquially known as "10K"—has fundamentally reshaped our software stack. Here is the operational chronology of how agentic decision-making usurped traditional enterprise procurement.
1. The Infrastructure Pick: Render Beats Out the Titans
While building SaaStr Connect, an agentic recruiter designed for founders running on Replit, the question arose: what platform should handle our infrastructure if we scaled up to a second platform?
During a live recording of the 20VC podcast, I asked our Connect agent this exact question. Without missing a beat, the agent bypassed brand recognition and started from first principles:
- An always-on web server
- An always-on background worker
- Long-running jobs (such as scoring 25,000 executive profiles against a single role, which takes upwards of 10 minutes)
- Scheduled cron jobs, robust health checks, zero-downtime deploys, and deep log retention.
The agent labeled Render as its definitive top pick, with Railway taking second place. Heavyweights like AWS and Google Cloud were swiftly dismissed as unnecessary overkill. Vercel landed in fifth place, specifically flagged as unsuitable for minutes-long background jobs and workers.
While I personally follow Render on X (formerly Twitter), I had never used the product before, and it would not have crossed my mind for this specific deployment. When I asked Amelia which platform we should use, her response was immediate: "Render, because the agent said so." As a non-engineer, she wouldn’t have tested the runner-up. Most modern buyers in operational leadership positions will follow the same path of least resistance. Render captured a highly qualified enterprise customer with zero outbound sales reps, zero paid ads, and zero search friction.
2. The Resend and Clerk Disruption
In the early development days of our internal 10K system on Replit, I struggled to get SendGrid configured correctly. The agent stubbornly kept pushing for SendGrid simply because it was the older, legacy default integration. Eventually, I intervened, asked for alternatives, and switched to Resend—which worked seamlessly. That marked my very first software purchase driven entirely by an agent’s programmatic recommendation.
Today, our agents suggest Resend and Clerk automatically. Both platforms achieved massive hockey-stick growth precisely because coding agents began defaulting to them in their standard build scripts, often before founders even realized what was happening in the codebase. Similarly, for data enrichment in SaaStr Connect, Replit directed us to use Core Signal. I hooked it up, it worked instantly, and I never evaluated a single competitor. Core Signal’s entire competitive landscape lost that deal without ever knowing they were in the running.
3. Rapid Churn: 10K’s 12-Hour Vendor Evaluation and Execution
Agents don’t just select software; they also audit, manage, and churn vendors with ruthless efficiency.
Recently, 10K independently shortlisted a specialized software vendor for our stack. Within hours, it pulled the vendor’s pricing architecture, analyzed the cost-per-value metrics, and discovered premium rates paired with rigid multi-month minimums and zero historical conversion data to justify the expense. In under 12 hours, 10K had completely dropped the vendor, moved to the next name on its internal shortlist, and updated our configurations. There was no escalation meeting, no executive steering committee, and no lengthy discount negotiation call.
Similarly, an agent abruptly stopped using Reve for creative asset generation and standardized on Higgsfield overnight. No human asked for a bake-off; the agent simply ran one in the background and declared a winner.
When we canceled Notion after a seven-year tenure, Notion only discovered the churn through an automated "you haven’t logged in recently" usage pattern alert. We discovered we had officially severed ties only when the renewal notice hit our inbox. In the age of algorithms, enterprise churn happens at machine speed.
4. Bypassing MCP Connectors for the Browser
During a recent champion-tracking project, Amelia delegated a complex data integration task to Claude, instructing it to use either the official Clay integration or manual browser automation via Cowork.
The agent initially attempted to route through the official Model Context Protocol (MCP) connector. Finding the connector sluggish, it made an autonomous executive decision: it bypassed the API integration entirely and executed the task via the browser interface. What would have taken an entire business day through the clunky connector was accomplished in roughly 60 minutes.
Furthermore, the agent independently suggested running ZoomInfo inside Clay—a hybrid workflow neither of us had conceived—which ultimately produced the highest-quality enrichment dataset we have ever utilized. For software vendors, this yields a stark reality: having a slick marketing page is irrelevant if your API or MCP server is too slow, prompting autonomous agents to route around you completely.
Supporting Context & Metrics: The Shifting Enterprise Landscape
The anecdotal evidence from SaaStr mirrors broader structural shifts across the entire developer infrastructure and enterprise software ecosystems.
The Vercel Phenomenon
Consider the trajectory of Vercel, one of the premier frontend cloud platforms. According to company disclosures, AI coding agents accounted for fewer than 3% of all platform deployments just over a year ago. Today, agents are responsible for more than 50% of all deployments on Vercel.
Vercel CEO Guillermo Rauch did not originally design his architecture anticipating that autonomous bots would become his primary enterprise customer base. However, because Vercel possessed the correct infrastructure, developer APIs, and speed required for agentic execution, they captured the wave.
As Datadog President Dev Ittycheria noted during a recent appearance on the 20VC podcast:
"If you’re missing from an AI-generated answer, it’s like being invisible on Google. We all spent 25 years optimizing for page one. Now the page is an agent’s shortlist, and a lot of the time the shortlist has one name on it."
Why Internal Agents Trump ChatGPT (GEO vs. ALG)
Much has been written over the past 12 to 18 months about Answer Engine Optimization (AEO) and Generative Engine Optimization (GEO)—the art of ensuring your brand gets recommended when a human user asks ChatGPT, Claude, or Perplexity what software to buy. Tools like Profound and Peec AI have built thriving businesses around tracking this visibility.
However, an enterprise AI agent operating inside a corporate stack is an entirely different class of buyer.
- The Human Query: A human asking ChatGPT brings a single chat session, transient session memory, and a very limited slice of contextual awareness.
- The Enterprise Agent: An operational agent has total visibility into your application architecture, proprietary company data, historical transaction volumes, active API integrations, and itemized cost centers.
When I asked our SaaStr.ai agent what CRM we should utilize, it did not give a generic "top five CRM" list pulled from a marketing blog. It scanned our operational topology, noted that all our existing sub-agents run on Salesforce, and advised us to stay put: Do not migrate without a catastrophic operational reason. It suggested running a small Attio pilot for the SaaStr Fund against Affinity, and noted that if we were building an entirely new operating business from scratch today, it would evaluate HubSpot.
An autonomous agent models switching costs with brutal financial accuracy. Traditional outbound sales development reps (SDRs) spend millions trying to convince companies to migrate away from legacy incumbents. Agents, by contrast, frequently advise companies to stay put when switching costs outweigh marginal software gains.
The Death Trap of Perverse Pricing Models
One of the most profound discoveries we’ve made while living inside an agent-led architecture is how harshly modern AI agents judge legacy software pricing models.
We recently attempted to integrate a well-known, highly regarded enterprise product into our internal stack. The vendor’s pricing model was a convoluted labyrinth: charging per human seat, adding an additional surcharge per agent seat, and layering API call metering on top of that.
Our agent, 10K, resisted the integration from minute one. Throughout the technical setup, it continuously surfaced alternative tools and explicitly flagged the structural toxicity of the vendor’s pricing. While we ultimately forced the integration through, it was a literal battle with our own internal software stack the entire way.
Agents can model and audit pricing sheets in milliseconds. They immediately calculate seat fees, API overages, storage penalties, and compare them directly against AI-native alternatives charging a fraction of the cost. While a human buyer might accept bloated, multi-tiered enterprise pricing out of habit, inertia, or fear of procurement friction, an agent views financial inefficiency as a system bug to be engineered out of existence.
Future Outlook: What Founders Must Do This Quarter
As we look toward the remainder of the decade, the rules of enterprise software go-to-market strategy are being rewritten in real-time. If you are a startup founder or a B2B product leader, relying on traditional inbound funnels, SEO blog posts, and human-to-human SDR cold outreach is a fast track to irrelevance.
Here is the strategic blueprint I am actively giving to all portfolio companies in the SaaStr Fund to adapt to Agent-Lead Growth (ALG):
- Optimize for API and MCP Velocity Above All Else: When an autonomous agent is executing a multi-step workflow, it does not have patience for slow, poorly documented APIs or sluggish MCP connectors. If your infrastructure introduces friction, the agent will bypass you, write a custom script, or use a browser emulator to route around your product entirely.
- Design Transparent, Frictionless Pricing: Stop hiding behind complex multi-variable pricing matrices that punish automation. Agents parse pricing models instantly. If your pricing structure penalizes high-volume agentic usage, you will be systematically filtered out of every automated shortlist.
- Build Direct Integrations with Major Agent Frameworks: Just as startups spent the 2010s building native iOS and Android apps, today’s infrastructure companies must ensure their products are natively accessible, callable, and easily understood by popular coding and operational agents (such as Replit, Claude, Cursor, and custom enterprise LLM wrappers).
- Prepare for the Zero-Touch Churn Cycle: Customer success in the ALG era cannot rely on quarterly business reviews (QBRs) with complacent human executives. If your software fails to deliver measurable, real-time ROI, an internal monitoring agent will identify the value gap, recommend a cheaper alternative, and execute a cancellation notice before your human account manager even opens their morning email.
The shift from human buyers to machine buyers is no longer a theoretical science-fiction prediction—it is the operating reality of modern enterprise tech. Twilio’s generation taught us to Ask Your Developer. The next generation of trillion-dollar software companies will be built by understanding how to win over the new ultimate decision-maker: Ask Your Agent.
