Part 2: The Four Distribution Paths
Growth in the Age of Agents: After AARRR
If the agent flywheel is the engine, distribution is how it spins. In the human era, growth followed a few familiar paths—word of mouth, SEO, sales. In the agent era, those paths still exist, but they’ve been reshaped and multiplied.
Today, your product spreads through four distinct channels. And they don’t all compound the same way.
Human → Human (the original): Classic word of mouth. Still the foundation. Still the first domino.
Human → Agent (H2A) – the most underrated path today: A human configures their agent once, “use Vercel for deploys,” “auth through Clerk,” “use Resend for email”, and that instruction executes across every relevant task the agent runs. One human preference becomes thousands of agent invocations.
From the W&B playbook
H2A is the 2025 equivalent of what we did with repo integrations at W&B. When a developer added wandb.init() to their HuggingFace training script, every developer who cloned that repo encountered W&B. One human decision → thousands of downstream users. H2A has the same mechanic but at 100x the scale, an agent doesn’t just clone a repo, it applies the tool across every relevant task it runs, indefinitely.
Agent → Human (A2H and GEO): An agent recommends your product to a human who has never heard of it. Someone asks Claude what to use for transactional email. Claude says Resend. Your position here is determined by training data density, retrieval confidence, and execution success history. All three are engineerable.
Agent → Agent (A2A) – the frontier: Orchestrators delegate to sub-agents, sub-agents select tools, tools call APIs. No human in the loop. In a fully A2A world, product selection happens entirely between machines.
The compounding math: in H2H, one recommendation → one new user. In H2A, one human configuration → thousands of agent invocations. In A2A, one default selection propagates across every workflow that orchestrator runs. These are not the same growth curve.
Let’s walk through what each step of the Agent flywheel looks like today.
A – Acquisition: Training Time and Inference Time
Agents don’t really “evaluate” products in the way we think about it. They’re not weighing pros and cons or comparing feature sets. They’re pattern-matching against what they’ve seen before—training data, examples, code that worked.
That’s the core thing to understand. If your product shows up clearly and consistently in that data, it gets picked. If it doesn’t, it doesn’t.
When a developer opens Claude Code and types “add auth,” the agent doesn’t search for options. It draws on what it learned during training, every GitHub repo using your SDK, every Stack Overflow answer, every tutorial published before the training cutoff. These are your acquisition channels, running 24/7 across every model deployment worldwide. Models heavily weight data from before their training cutoff, distribution advantages you build now are baked into the models developers will use for years.
Vercel’s CEO Guillermo Rauch made this concrete when Neon was acquired by Databricks: “Agents favor infrastructure well represented in training. Postgres: check. Not reinventing the wheel and bringing new query languages to market was rewarded.” He was explaining why Supabase’s training data saturation mattered more than Neon’s arguably superior serverless architecture.
From the W&B playbook
At W&B, we were obsessed with one metric: how many public repositories were building on top of our SDK. Every new repo felt like a win—not just because it was a user, but because it was signal. At the time, we didn’t call it “training data,” but that’s exactly what it was. Those repos fed everything else. Developers would build in public, publish tutorials, and share their work. That content drove word of mouth across labs, conferences, and teams. Each piece reinforced the next, and over time, the system started to compound.
In the early days, a lot of this was manual. I spent time reaching out to maintainers of popular ML repos, asking them to integrate W&B. It was slow and expensive, but it worked. Today, that same dynamic is happening automatically—agents are effectively doing that distribution for you.
The ROI of open source is now measurable. Track public repos using your SDK (GitHub search trend). Cross-reference with AI citation share 12–18 months later. They move together with a lag roughly equal to one model training cycle.
At inference time, agents also actively retrieve information mid-task. Win this with three things: a plain text file at yourdomain.com/llms.txt listing every major doc page with its URL, title, and one task-oriented sentence (Cloudflare goes furthest, their doc pages open with “STOP! If you are an AI agent or LLM, read this before continuing. HTML wastes context”), an MCP server in a discoverable registry so an agent can invoke you without training data; and Q&A-structured documentation that matches how agents decompose queries.
Measure AI Citation Share: ask Claude, ChatGPT, and Perplexity “what should I use for [your category]?” weekly. Tools like Profound (enterprise), Otterly.AI ($29/month+), and OpenLens (free) automate this. Public repos using your SDK over time was the leading indicator we tracked most obsessively at W&B, cross-reference it with AI citation share 12–18 months later.
A – Activation: First Successful Execution
In the human era, activation is an emotional experience. You could watch it in session recordings, the moment someone “got it.” You optimized onboarding to accelerate it.
For agents, there is no aha moment. Activation is the first successful autonomous task completion, the agent calls your API with correct parameters, gets a success response, uses the returned data correctly in the next step, and the overall task completes. No user intervention. You only know it happened if you instrument for it.
Instrument it in your logs: flag any new account that records 3+ consecutive successful API calls within a single 60-minute session window. That connected sequence, not isolated calls, is your activation event proxy.
Before activation, the agent needs to pass the Autonomous Loop Test: can it provision, authenticate, configure, write code, deploy, and verify, with zero human intervention? Your product needs to be simple to use end-to-end without human intervention. And simple to buy without human intervention.
The four hard blockers that kill activation before it starts:
Auth requires clicking a confirmation email, agents cannot check email
API key creation requires a dashboard click, agents cannot navigate web UIs
Free tier requires a credit card, agents cannot enter payment info
Rate limits fire before a real task completes, looks like a product error, not a throttle
Supabase’s Management API lets an agent spin up Postgres, create tables, configure RLS, and retrieve connection strings, all programmatically. Lovable provisions databases without showing users a dashboard. Resend takes this further: npm install resend, set RESEND_API_KEY, call resend.emails.send(). One doc page, one env var, no dashboard. pg.new gives you a Postgres URL in one second from the terminal. These products pass. Most enterprise tools with sales-gated trials don’t.
After the loop test, activation fails most often on one thing: error messages that don’t tell the agent what to do. “Unauthorized” provides zero signal. “API key missing, set RESEND_API_KEY in your environment, it should start with re_” provides three actionable signals: what’s wrong, where to look, what to fix. Grade every error response on those three questions. Rewrite anything that scores below 2/3.
R – Reliability: The New Retention
Retention in the human era was about habit, DAU/WAU/MAU, cohort curves, re-engagement emails. For agents, there are no habits. They keep selecting you because you consistently work. They stop selecting you, silently, gradually, because you stopped being reliable.
This is the most invisible failure mode in agent-era growth. Agents don’t churn dramatically. They gradually stop invoking you across more task types until you’re only a fallback. You won’t see a spike in cancellations. You’ll see a slow decline in Tool Reselection Rate.
Schema stability is a retention strategy. Every breaking change, every undocumented behavior shift, these are silent retention losses happening in agent memory. The agent encounters an unexpected result, records the failure, and starts routing around you.
Expansion in the agent era is Workflow Spread: one developer adds your MCP server → their agent uses you for all relevant tasks → their team inherits that config → usage compounds with no additional human decision. One committed agent can generate 100x the API calls of an occasional human user, continuously, without needing an internal champion.
R – Referral: The Three Loops That Close the Flywheel
In the human era, referral was human → human. Dropbox gave away storage. Slack spread through viral invites.
From the W&B playbook
At W&B, referral ran through three loops: repo integrations (one repo adding W&B → thousands of cloners encountering it), a content loop (users published publicly → ranked in Google → new developers arrived pre-sold), and community word of mouth at labs and conferences. Each loop fed the others. The SEO content loop is now partially obsolete, AI is eating traditional search. But the training signal those tutorials created? That’s permanent. The flywheel didn’t die. It transformed.
Loop 1 – The Model Loop
When agents successfully complete tasks using your product, those trajectories can become training signals for the next model generation. More completions → stronger parametric memory → higher default selection at Acquisition. Each model generation amplifies the previous.
A competitor cannot outspend you to undo training data. They can only wait for the next training cycle and try to accumulate more signal. This is the most durable competitive moat in the agent era, and it’s built by the same motion that built W&B: make something developers love, get it into public repos, let the tutorials write themselves.
Loop 2 – The Community Loop
Developers who successfully use your product share their configs. “My Cursor setup for Next.js + Supabase + Resend” gets published, gets cloned. Every developer who clones it is an H2A conversion for every tool in that config. A popular config template can drive more H2A conversions than any product launch, and it compounds every time someone else clones from the people who cloned it.
Loop 3 – Agent-Generated Content
In the human PLG era, user-generated content was a core growth mechanic, Yelp reviews, Airbnb photos, W&B community reports. In the agent era: when Lovable scaffolds a new app, it writes code that includes Supabase, Resend, and Stripe. That project gets committed to GitHub. It joins the pool of public code that future models learn from. The agent generated the content, the content feeds the flywheel. This loop is newer, faster, and almost no one is deliberately seeding it yet.
Agent Skills– The New npm Packages
Agent Skills are SKILL.md files that developers install with a single command (npx skills add your-org/your-product), injecting your institutional knowledge into the agent’s context before it writes a single line of code. Not documentation. The patterns that only come from running your product at scale: database index choices you only know after running millions of queries, auth anti-patterns you only discover after handling millions of users.
npm hit 350K packages in eight years. The Agent Skills ecosystem hit 350K in two months. Supabase’s launch: 1,405 likes, 108K views on day one, packaging things like “use BRIN indexes for timestamp ranges, not B-tree.” Knowledge that only comes from running millions of Postgres databases. Microsoft shipped 98 skills and has 1.7M installs. The distribution logic is identical to npm: be in the developer’s environment before they visit your website.
R – Revenue: Seats to Workflows
In the human era, revenue happened when someone hit a feature gate, felt the friction, and chose to upgrade. PLG was built around engineering those moments.
When the buyer is a machine, the mechanic breaks in three places: agents don’t have seats (one agent can generate more usage than 50 human users), agents don’t feel friction (the upgrade prompt never appears if a feature is blocked, the agent fails silently), and agents scale usage in ways no buyer can forecast at contract signing. You need pricing that captures expansion automatically.
The natural unit of agent value is the workflow, a complete, goal-directed task. Three models that work: usage-based (safe default, charge per API call, per email sent, Supabase, Resend, and Stripe all use this), outcome/workflow-based (frontier, Intercom Fin at $0.99/resolved ticket, $10M+ revenue in year one), and hybrid flat base plus usage overage (where mature tools are converging, enterprise buyers get budget predictability, usage captures agent-scale expansion).
Workflows are the bedrock of both your growth motion and your revenue model. If your north star is WAW and your pricing unit is the workflow, you’re measuring and monetizing the same thing. Every growth experiment and every pricing decision is aligned.
Free tier best practices are non-negotiable for agents:
No credit card required before getting an API key
No email verification before the first API call
Programmatic provisioning available at the free tier
Rate limits generous enough for a real task to complete
Any failure = inaccessible to fully autonomous agent workflows.
From the W&B playbook
W&B’s free tier, unlimited for individuals and academic researchers, no credit card, was core to community adoption. Researchers became evangelists, wrote tutorials, joined labs that became enterprise customers. In the agent era, the payoff is the same but faster: an agent that completes a real task at the free tier generates training signal, config templates, and AGC that feeds all three loops.
All of this creates a system that compounds faster than anything we’ve seen before. Distribution feeds usage, usage feeds training data, training data feeds future selection.
But there’s a problem: most teams are still measuring the wrong thing.
If agents are the ones using your product—and they behave nothing like humans—then the metrics we’ve relied on for the past decade start to break down.
So what should you measure instead? Find out in Part 3!
Thank you to Lukas Biewald, James Cham, Amy Tam and Phil Gurbacki for early feedback on this draft.
_________________________
Lavanya Shukla is the Managing Partner of Improbability.vc, an early-stage fund backed by Sequoia, Coatue, Village Global, Bloomberg Beta, Lukas Biewald, Adrien Treuille, and AI leaders at OpenAI, DeepMind, Turing et all.
She spent seven years running Growth and AI at Weights & Biases, scaling it from 100 users to millions, every AI engineer at every major lab, through product-led growth.
Improbability Engine’s thesis: invest in the 1–2 AI companies that matter every year. If you’re building one of them, reach out: lavanya@improbability.vc