What Is Agent-Led Growth (ALG)?

Agent-led growth (ALG) is customer acquisition and product adoption driven by AI agents discovering, recommending, selecting, and using products on a person’s behalf. For developer tools, that can mean a coding agent choosing a database, installing its SDK, and building a working integration in a single session.

A recommendation creates an opportunity. Successful implementation turns that opportunity into product usage. Gauge connects those stages through AI search visibility, agent preference, and agent experience. This guide explains the growth motion, how it relates to AEO and GEO, and what teams can measure and improve today.

In this example, a developer asks for email sending without naming a vendor. The agent selects a provider, installs its package, and wires it into the project. The developer can review the result without independently researching every alternative. Website analytics alone cannot explain that vendor decision.

What Does ALG Mean in Marketing?

ALG stands for agent-led growth. The growth motion includes both discovery and execution: an AI system can introduce someone to a product, choose it for a task, and carry out the work needed to use it. Coding agents are a practical example today because they can research a tool and implement it within the same workflow.

Growth motion	Who drives the next step?	Example
Sales-led growth (SLG)	A salesperson guides a buyer	A sales team demos a database and helps close the purchase.
Product-led growth (PLG)	A person tries the product	A developer signs up, follows a quickstart, and invites their team.
Agent-led growth (ALG)	An AI agent acts toward a person's goal	A coding agent selects the database, installs its SDK, and implements the feature.

These motions can coexist. An agent might discover a product before a person talks to sales, or complete onboarding inside a product-led signup flow.

How Agent-Led Growth Relates to AEO, GEO, and SEO

SEO helps people and agents find pages through search. AEO (answer engine optimization) and GEO (generative engine optimization) focus on visibility in AI-generated answers. Agent-led growth follows that discovery through to product selection and successful usage.

For example, an AI answer might recommend Supabase when someone asks which database to use. That is an AI visibility outcome. If a coding agent then installs the Supabase client, configures authentication, and leaves working code in the project, it has also driven adoption. A mention, a citation, an installation, and an active customer are different outcomes and should be measured separately.

Gauge organizes this work into three connected capabilities:

• AI search visibility: measure recommendations and citations, understand the sources behind them, and improve the content that answers buyers' questions.
• Agent preference optimization (APO): measure which tools coding agents choose for open-ended tasks and investigate why.
• Agent experience (AX): evaluate whether agents can successfully set up and use your product after selecting it.

The Two Sides of Coding-Agent Adoption

For coding agents, preference and experience address different failure points: getting selected and completing the implementation.

APO (Agent Preference Optimization). Become the preferred choice.

APO is the AI visibility side of Agent Led Growth. It is about shaping which tools and brands coding agents know, trust, recommend, and build with. The prompt sets the goal, the session context narrows the field, and the agent researches from there and picks one. That pick is the whole decision. The developer sees what won and never learns what lost.

Two things move it:

• Shape model priors. Live in the training data of the next models.
• Win agent web search. SEO and AEO for the queries agents actually run.

AX (Agent Experience). Get implemented properly.

AX is how well an agent can actually use your product once it picks you. Everything the agent touches counts: your docs, your setup, your API, your errors, your CLI. If it can get from install to working code without a human stepping in, your AX is good. If it guesses wrong, gets stuck, or gives up, it is not.

Three things move it:

• Agent-readable docs. Examples and recipes, not prose.
• Frictionless onboarding. Seamless API key setup and installation.
• Predictable API. Types, SDKs, and errors it can self-correct from.

Fail APO and you are never in the running. Fail AX and you get picked, break during the install, and get replaced before the developer has finished reading the diff. APO gets you into the file. AX keeps you there.

How Agents Form Preferences (APO)

Agent preference is not formed in one moment. It is a pipeline, and you can get dropped at any stage.

Stage 1: The Model's Knowledge

What the model believes before anything is typed. Baked in at training.

• Slowest to move, most valuable to own. Hard to influence, durable once you are in, re-rolled every release.
• A prior, not a lookup. The model is recalling, not searching.
• Different per model. Claude, GPT, and Gemini hold different defaults for the same category.

Stage 2: The Context

Everything in front of the model when it decides. Set per session. Narrows the field before a single search runs, and often settles it.

• The prompt. A named tool ends the decision before it starts. An unnamed one hands it to the agent for its recommendation.
• The codebase. Whatever is already wired in becomes the default, already-embedded tools guide next steps.
• Skills and rules files. CLAUDE.md and AGENTS.md are standing orders, applied on every run without being asked for.
• User memory and preferences. Where the agent learns the developer's taste. Standing preferences on style, language, and coding patterns.

Each stage runs on a different clock, and the clock decides how you invest against it. Model knowledge is the hardest to influence and gets re-rolled every release, but the effect lasts longest once you are in. Context is instant and resets every session. Research is the fastest surface to move, and it runs live on every query.

Stage 3: Research

If the agent decides to do web research, this is where strong SEO and AEO/GEO pay off, just against a different surface. Live, per query.

• Rank for the model's terms, not yours. The agent writes the queries. They are longer, more literal, and task-shaped.
• Multiple searches, run in parallel. Several angles at once, not one query.
• Product documentation. Ranking gets the agent to the page. The page has to explain how to implement, concretely enough to write working code from.
• Your docs are the fetch. Across 500 runs, docs took 55% of all page fetches. Source code 18%, package registries 11%, third party content 5%. The blogs and listicles you have been buying are rounding errors here.
• Setup pages do the heavy lifting. Of the docs fetched: setup 26%, README 18%, quickstart 15%, API reference 13%, package registry 11%, dependencies 1%. Setup, README, and quickstart together are nearly 60%, which is the first ten minutes of using your product.

How to Optimize for Agent Led Growth

Track. Understand who coding agents recommend, broken out by agent and model, and where they go to research. Your share of voice against competitors, which sources get searched and fetched, and where your tool gets implemented.

Analyze. You need to be able to go inside the runs. Every session leaves a trace, and that trace is the only place the agent experience is visible. You should know what the agent searched, which sources it opened and which it skipped, what it read from your docs, and whether it named you, a competitor, or nothing. Then the build. What it installed, which version of your API it wrote against, whether the integration worked, what it guessed wrong, where it got stuck, and whether it recovered or gave up on you.

Act. Fix what the runs showed you, then re-run the same prompts to see if it worked. Some fixes are documentation: the setup step agents keep missing, the version the model thinks is current, the quickstart that skips what they needed. Some fixes are the product: config that should not need a decision, errors that leave the agent stuck, an install that takes six steps instead of one. Either way you make the change, run the same prompts again, and see if agents behave differently.

Example KPIs to Track:

• Share of voice. How often agents name you versus competitors.
• Fetch rate. Whether your docs get opened, and which pages.
• Install rate. How often a session ends with you in the project.
• Mention to install conversion. Where you leak between getting named and getting used.
• Integration success rate. How often the agent ships something that works without human correction.

How Gauge Helps With ALG (Agent Led Growth)

Gauge is the Agent-Led Growth platform. Its Coding Agents product measures agent preference and agent experience. It runs real coding agents against real prompts and repositories in isolated sandboxes and captures the full trace of every session: every search, every page fetched, every package installed, every file written. That becomes the numbers above, sliced by agent, model, language, framework, greenfield versus existing codebase, and branded versus unbranded prompts. The splits matter more than the averages, because you can dominate on Claude in TypeScript and be invisible to Codex in Python.

You can open any run and read what the agent did, from the first search to the last line, including the moment it chose a competitor and what it had just read. Failures get grouped across sessions, so one missing setup step breaking fourteen runs surfaces as a single ranked item with fourteen pieces of evidence. That ranking tells you whether a fix is worth a sprint.

Then you act and verify. Use the session evidence to identify documentation, onboarding, and product fixes. Gauge lets you compare documentation and skill changes in controlled evaluations before your team ships them. Keep the prompts and environment consistent, repeat the runs, and compare task outcomes against the baseline. This helps distinguish a useful change from a one-off successful run.

It runs on a schedule, because your numbers come from model weights that change several times a year. A new release shifts defaults, research habits, and what the model believes about your category. On a standing cadence a regression shows up as a trend break in days instead of a quarter of churn you cannot explain.

Customer Examples of Agent-Led Growth

• PostHog: uses Gauge to understand AI search visibility and improve its AEO work. This is the discovery side of the growth motion.
• Clerk: evaluates how coding agents build authentication flows and uses the traces to find integration friction.
• Neo4j: evaluates agent journeys across local and Aura cloud environments to prioritize documentation and onboarding work.

How Do You Measure Agent-Led Growth?

Start with representative tasks, repositories, and agent configurations. Measure recommendation and selection rates for unbranded tasks, then installation and task completion for implementation tasks. Inspect failed runs to find the cause, make a targeted change, and rerun the benchmark.

Evaluation results describe the tested scenarios. They do not directly count new customers or revenue. Connect those findings to your own signups, activation, retained usage, and attribution data to understand business impact. Our agent-led growth metrics guide explains what to measure, and our ALG strategy guide lays out the ongoing improvement process.

Getting Started With Agent-Led Growth

Choose a user task where your product should be considered. Test whether agents discover it, select it, and complete the implementation. Start with the recurring failure that most often prevents a working result, then measure again after the fix.

Explore Gauge's Agent-Led Growth platform, see the Coding Agents product, or read the CLI guide to run evaluations from your existing workflow.