Executive Overview
In 2021, tech entrepreneur Jeff Lawson popularized a paradigm-shifting concept in his book Ask Your Developer. Lawson argued that software procurement had fundamentally changed: developers had evolved into the real buyers of a massive slice of business-to-business (B2B) software. If a company wanted to close Twilio-scale infrastructure deals, its sales and product teams had to win over the engineer. Because engineers typically held the technical leverage, they brought the corporate budget with them, rendering traditional top-down enterprise software sales pitches obsolete.
Five years later, that historical power dynamic is undergoing another radical evolution—one layer down.
In modern highly optimized digital organizations, human-led vendor discovery is rapidly taking a back seat to autonomous execution. At SaaStr, operations now run on more than 21 active AI agents in production, managed by a lean team of just three humans. A growing majority of vendor discovery, software evaluation, consolidation, and outright contract termination no longer begin or end in executive boardrooms or developer Slack channels. Instead, they begin with a query posed to an internal AI agent—and in many cases, conclude right there.
This phenomenon marks the birth of Agent-Led Growth (ALG). Just as "Ask Your Developer" defined the 2020s software boom, "Ask Your Agent" is defining the next era of enterprise technology consumption. For B2B founders, go-to-market (GTM) leaders, and venture capitalists, understanding this shift is no longer optional. If your product is invisible to an AI agent’s runtime context, you are effectively invisible to the modern enterprise.
Detailed Chronology: Inside the SaaStr AI Experiment
To understand how Agent-Led Growth functions in practice, one must examine real-world deployments. Over the past several months, SaaStr’s internal operations—spearheaded by founder Jason Lemkin and AI VP of Revenue "10K"—have provided a real-time stress test of how software is chosen, vetted, and discarded by automated systems.
1. The Autonomous Selection of Infrastructure: Render vs. the Tech Giants
While building SaaStr Connect, an agentic recruiter designed to help founders match talent, the engineering team relied on Replit. During a live 20VC recording, Lemkin asked the Connect agent to evaluate infrastructure platforms for potential long-term scaling.
Without human intervention, the agent analyzed the app’s technical architecture: an always-on web server, an always-on background worker, long-running jobs (such as scoring 25,000 corporate executives against a single job description over 10 minutes), scheduled jobs, health checks, zero-downtime deployments, and extended log retention.
The agent labeled Render as its primary recommendation, placing Railway in second. Traditional giants AWS and Google Cloud were flagged as structural overkill, while Vercel landed in fifth place due to its limitations with minute-long background worker jobs.
“Render got a qualified lead with no sales rep, no ad, and no search result.”
For Render, this win happened entirely outside the traditional funnel. They did not win a Google search impression, nor did they pay for an ad or host an SDR meeting. They won because an agent ingested the precise system requirements and outputted a definitive recommendation.
2. The Death of the Traditional Software Evaluation: Resend and Core Signal
When building the "10K" agent framework, Lemkin initially hit integration roadblocks with SendGrid. The agent stubbornly pushed for SendGrid out of historical inertia, as it was the older, natively supported integration. However, once queried about alternatives, the agent successfully pivoted to Resend, which executed seamlessly. Today, coding agents independently default to Resend, bypassing human evaluation entirely.
Similarly, Core Signal bypassed the competitive evaluation phase altogether. When the Replit-backed agent suggested Core Signal for data enrichment within SaaStr Connect, it was immediately integrated. Its competitors lost out on the deal before they even knew a procurement process was underway.
3. The Churn Cycle: Fast Shortlisting and Brute-Force Cancellation
Agents do not just discover software; they actively audit and cancel it. In one instance, 10K independently shortlisted a vendor, parsed their pricing model, and discovered a combination of premium rates, multi-month upfront minimums, and a complete lack of verifiable conversion data. Within 12 hours, the agent dropped the vendor from its list and moved to the next option—all without human escalation, discount negotiations, or corporate meetings.
In another instance, an agent abruptly terminated a long-standing relationship with a creative asset platform to standardize on Higgsfield, executing a bake-off entirely autonomously.
Even long-term legacy commitments are vulnerable. When SaaStr canceled its subscription to Notion after seven years of use, the decision was driven by utilization pattern matching. By the time human leadership realized the switch had occurred, the subscription had already lapsed.
4. When the Agent Says "Build It Yourself"
Perhaps the most disruptive aspect of ALG is an agent’s willingness to bypass commercial software entirely. When asked what tool to use for Answer Engine Optimization (AEO), 10K recommended against purchasing a dedicated platform. Instead, it suggested running a free trial of Peec AI purely as a benchmark, and immediately began constructing a custom internal AEO dashboard.
The agent’s programmatic reasoning was simple: existing third-party AEO tools excelled at tracking metrics but lacked the integration depth to dynamically act on data gaps. Because 10K already controlled dozens of sub-agents, it was more efficient to build a bespoke solution natively. This dynamic has played out repeatedly, with agents replacing established scheduling, CMS, and hosting platforms with in-house builds created in under an hour.
Supporting Context & Metrics: The Shift in Developer Infrastructure
The macro data confirms that agentic routing is transforming foundational developer infrastructure.
At Vercel, CEO Guillermo Rauch noted a staggering transformation in deployment mechanics: agents transitioned from accounting for under 3% of total deployments to more than half in roughly a year. Vercel did not rearchitect its business model specifically to target autonomous AI coders; rather, its infrastructure happened to be structurally optimized for programmatic consumption when the agent wave hit.
As Datadog President Dev Ittycheria pointed out during a recent appearance on 20VC:
“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.”
ChatGPT Context vs. Enterprise Application Context
Much has been written about Answer Engine Optimization (AEO) and Generative Engine Optimization (GEO)—the practice of optimizing content so that generic consumer AI models like ChatGPT or Claude recommend your brand to human users.
However, corporate enterprise agents operate differently. A generic consumer LLM relies on a limited context window provided by a single human user. In contrast, an enterprise AI agent possesses total context:
- Proprietary corporate data volumes
- Existing integration architectures
- Historical cloud and software expenditures
- Real-time utilization patterns and performance bottlenecks
When an enterprise agent evaluates a CRM, it does not look at marketing brochures. It evaluates whether the operational costs, API latency, and data synchronization overhead justify a migration. For instance, when SaaStr’s agent evaluated its CRM stack, it noted that while HubSpot might make sense for a brand-new operating business, migrating away from Salesforce would introduce unnecessary switching costs and friction for existing third-party agents. It issued a directive that no human sales rep could ever match: Stay put.
Key Friction Points in Agentic Procurement
As autonomous procurement matures, enterprise software vendors are beginning to run headfirst into the algorithmic friction of agentic buyers.
- The Death of Multi-Layered Pricing Models: When companies attempt to implement legacy pricing models—charging simultaneously for human seats, agent seats, and API call volumes—AI agents flag the discrepancy instantly. Agents model software cost structures in milliseconds, systematically comparing legacy pricing against lean, AI-native competitors.
- Slow API and MCP Latency: During a recent champion-tracking project, an agent was given the choice between a standardized Model Context Protocol (MCP) connector and a direct browser automation workflow (Cowork). Because the MCP connector suffered from high latency, the agent bypassed it entirely and completed the task via browser execution in a fraction of the time. If your API or MCP server is slow, agents will actively route around your product.
- The Paradox of Blind Adoption: Conversely, agents are not immune to efficiency heuristics. When building sponsor pages, SaaStr’s website agent instantly deployed Microsoft Clarity for heat-mapping without running a comparative search. Products that secure a spot in an agent’s default configuration libraries capture immediate market share.
Future Outlook: Navigating the Era of Agent-Led Growth
The rules of B2B marketing, sales development, and product-led growth (PLG) are being rewritten in real time. As AI agents evolve from simple chat-based assistants into autonomous chief operators—such as SaaStr’s "10K"—the traditional enterprise sales funnel faces structural obsolescence.
Founders pitching software to modern tech companies are increasingly greeted not by human executives, but by administrative agents instructed to pass pitches up to operational AI controllers.
What Founders Must Do This Quarter
For early-stage and growth-stage software companies navigating the landscape of Agent-Led Growth, survival requires an immediate operational pivot:
- Optimize for Machine Readability: Ensure your documentation, API endpoints, and MCP servers are meticulously structured. If an agent cannot parse your capabilities instantly, you will be omitted from shortlists.
- Rationalize Your Pricing: Strip away punitive seat-plus-usage hybrid models. Agents benchmark pricing models mathematically; convoluted pricing structures invite immediate algorithmic churn.
- Target the Agent, Not Just the Buyer: Shift product positioning to appeal to the operational constraints of autonomous agents (speed, reliability, deterministic API execution) rather than relying purely on human emotional appeals or brand advertising.
The era of human-dominated software discovery is drawing to a close. Just as the 2010s belonged to the cloud and the early 2020s belonged to the developer, the next decade belongs to the agent. Companies that adapt to Agent-Led Growth will capture unprecedented, zero-friction distribution; those that ignore it will find themselves locked out of the enterprise entirely.
