Product-led growth is remembered as a commercial decision: free tier, self-serve signup, expansion without a salesperson. That is the half that fits on a slide.
The half that did the work was the interface. Removing the salesperson does not remove the job the salesperson was doing — it relocates it into the product, where onboarding, the empty state and the first useful outcome have to carry a decision that a human used to carry in a meeting. Slack, Dropbox and Figma were user-experience companies with a pricing page. The motion was commercial; the discipline underneath it was UX, and the discipline is what made the motion work.
A second evaluator has now appeared. It cannot see any of that.
The lineage is short and already written
Don Norman coined user experience in 1993. Jeremiah Lee coined developer experience in 2011, when distribution started depending on whether a developer could get a key and a working call inside five minutes. In January 2025, Mathias Biilmann named agent experience — “the holistic experience AI agents will have as the user of a product or platform” — and made the point most vendors are still getting backwards:
“Too many companies are focusing on adding shallow AI features all over their products or building yet another AI agent. The real breakthrough will be thinking about how your customers’ favorite agents can help them derive more value from your product.”
Each name arrived when a new consumer started deciding adoption. The pattern is not that one discipline replaces the last. It is that each new consumer is opaque to the surface built for the previous one. Your onboarding flow, your empty state, your tooltips: an agent reading your OpenAPI document encounters none of it.
Two things are called agent-led growth
Before going further it is worth separating them, because the term is used for two motions that share nothing but the acronym.
One is agents deployed on your side of the table — agentic SDRs, AI-written content, pipeline automation. Insight Partners is right to call this an efficiency gain on existing motions rather than a structural change. The other is an agent working for the buyer: researching vendors, compiling the feature matrix, testing the product, forming a preference before anyone on your side knows an evaluation happened.
Their line separating the two is the one worth keeping:
“Supply-side ALG improves the economics of your current funnel. Demand-side ALG changes whose funnel it is.”
Only the second one is an agent-experience problem. Shipping your own assistant does nothing about the agent your customer already has.
The evidence is in, in one category
The developer ecosystem is where agents were handed authority earliest, so it is where this is measurable rather than predicted.
Supabase went from one million to 4.5 million developers in under twelve months, and its CEO credited the dynamic directly: “Our sign-up rate doubled in three months because of Bolt, Lovable, Cursor.” Resend, a transactional email provider founded in 2023, is chosen by Claude Code 63% of the time when asked to add email to a repository. SendGrid — far larger, far better known — is chosen 7% of the time.
No campaign produced that split. It is the residue of a machine repeatedly picking whichever option cost it the least effort to be confident about. Insight’s reading of why is four properties, and only one of them is a marketing decision:
- extensive, machine-readable documentation
- free tiers that remove the budget-approval step
- clean, predictable APIs that minimise the decisions an agent has to make
- heavy representation in training data through open-source work
Three of the four are engineering. That is what it looks like when the discipline underneath the motion changes.
Same metric, new units
UX had time-to-value: how fast a human reaches the first useful outcome. The agent-side equivalent, named by both Insight and Explorium, is token-to-value — how many tokens an agent burns going from problem-aware to implemented.
This is not a rhetorical swap of one unit for another. Explorium’s illustration: a product returning typed field-value pairs costs 150–300 tokens per record; one returning unstructured markup costs 3,000–10,000. At ten thousand records that is a difference of tens of millions of tokens for the same answer.
What makes it a growth metric rather than an infrastructure one is when it is spent. The agent burns those tokens during the evaluation, before anything has been bought. A surface that is expensive to understand loses before it ever gets the chance to be expensive to run.
The part that makes agent experience harder than UX
Here is the asymmetry, and it is the reason this cannot be treated as UX with different colours.
UX had the richest observation toolkit any design discipline has ever had. Usability testing, session recordings, heatmaps, funnel analytics, support tickets, NPS verbatims, an angry screenshot on social media. You could watch a human struggle, in replay, and the struggle told you where the product was wrong. A mediocre first version got corrected into a good one whether you planned for it or not, because the consumer generated the correction for free.
An agent generates none of it. It reads your document, picks the endpoint whose name looks closest to the task, guesses a parameter, gets a 400, retries, gets a 200 it half-understands, and tells the user your product cannot do that. No ticket. No session to replay. No churn reason code. The user does not blame the agent, because the agent sounded confident.
| Product-led growth | Agent-led growth | |
|---|---|---|
| Who evaluates | The human user | The agent they delegated to |
| What it reads | Onboarding, the empty state, the UI | Docs, OpenAPI, the tool surface |
| The effort metric | Time-to-value | Token-to-value, priced per turn |
| When it goes wrong | Tickets, heatmaps, NPS verbatims | Silent retries, and a wrong answer |
That last row is why the design has to be right earlier. Outside-in design was good practice for UX; for agent experience it is the only practice available, because there is no inside-out signal coming back to correct you.
The infrastructure arrived, which removes the excuse
On 12 February 2026, Google and Microsoft published WebMCP as an open standard, and it shipped in Chrome 146. In its simplest form you annotate existing forms with a tool name and description, and the browser translates them into structured tool schemas an agent can invoke — no backend change required.
This matters less as a technology than as a deadline. It removes “we would have to re-architect” as a reason not to be evaluable, which means the vendors in your category who want to be evaluable now can be, quickly. And the advantage compounds: agents that find your tools reliable preferentially recommend you, which is brand trust with the human taken out of it.
But annotating the forms is not designing the surface
This is where the go-to-market analysis and the engineering reality part company, and it is the part most writing on agent-led growth skips.
“Make yourself callable” is not a difficulty gradient. It is a design problem with a wrong answer that is very easy to reach: run the importer over a 300-operation OpenAPI document, ship 300 tools, declare the product agent-ready. The agent then spends its context window disambiguating near-identical options before it reasons about the task at all, and picks one of the wrong ones. We have made that argument at length, and the 200-tool bottleneck is what it looks like in production.
Notice that this is precisely a token-to-value failure. A vendor optimising for “agents can reach everything we do” is directly worsening the metric that decides whether they get picked. Coverage and legibility pull against each other, and the agent rewards legibility.
Which is the same lesson UX learned. Exposing every feature in the navigation was never good design; the work was deciding what the user needed at that moment and showing them only that. The tool surface is the same problem with a different consumer. Your quickstarts are already the shortlist — they encode which jobs customers hire the product to do, which makes them a better starting point than your endpoint inventory.
Where this leaves a vendor
Documentation is a go-to-market asset now, not a support function. The questions that come up in every demo but are not in your public collateral are exactly the questions an agent will hit — and each one costs tokens it spends deciding about you.
Your product is becoming a set of tools inside somebody else’s agent, whether you design for that or not. The only question is whether those tools were designed or scraped off your REST surface by an importer.
The surface has to be an artifact someone can review. Not because review is virtuous, but because an enterprise that wants a narrower version of your surface will otherwise fork your SDK and build it badly. A declarative file they can narrow keeps them on your upstream.
That last one is the part we build. Ikanos is an Apache 2.0 specification and runtime where the surface an agent sees is one declarative file — the operations you import, the task-shaped flows you compose from them, and the MCP and REST projections of those flows — reviewed like any pull request before a credential is attached to it, with OpenTelemetry traces and per-capability metrics once it runs. Polychro lints that file, so “is this surface legible?” becomes a check that runs in CI rather than a judgement someone makes once and forgets.
Finding out what an agent currently sees when it meets your product costs a repository and an afternoon. That is cheaper than most of what is on a go-to-market roadmap, and it answers a question none of the rest of it can.
The takeaway
- Product-led growth was a commercial motion resting on a design discipline. The motion got the credit; UX did the work.
- A second evaluator arrived and none of that surface is legible to it. Agent experience is the discipline the new motion rests on.
- Token-to-value is the effort metric, and it is spent during evaluation rather than after the sale.
- Agent experience is harder than UX in exactly one way, and it is decisive: no heatmaps, no tickets, no verbatims. The consumer that decides against you leaves no trace.
- Coverage is not readiness. Exposing 300 operations makes token-to-value worse. The products winning defaults expose fewer, clearer things.
Further reading
- 🤖 Your newest customer is an agent — the silent funnel, and what it means for SaaS vendors
- 🧭 Designing agent experience outside-in — which half of customer experience transfers, and which half breaks
- ✂️ Importing your API into MCP is usually the wrong move — why selection is a subtraction operator
- 🔄 From data and APIs to capabilities — quickstarts as the capability backlog
- 🎨 Introducing AX: why agent experience matters — Mathias Biilmann, January 2025; where the term was named
- 📈 Agent-led growth: the next GTM motion is already here — Neal Behrend, Insight Partners, March 2026; the demand/supply distinction and the Supabase and Resend numbers
- 🎙️ From SEO to agent-led growth — James Cadwallader on Sequoia’s Training Data; “the person walking through the door has changed”
- 📊 Agent-led growth vs PLG — Explorium, August 2026; the token-to-value arithmetic
- ⚙️ Ikanos · 🔍 Polychro · 🎓 Shipyard Playground
