PLG Meets AI: the new activation playbook

Webinar recap: hosted by Mickey Alon and Ramli John

Why we ran this session

Every product team is under the same pressure: go AI-native, fast, without re-platforming the product or standing up a research team. Most teams add a chat window, watch it answer questions nobody asked, and see activation stay exactly where it was.

The gap isn't effort. It's that the playbook changed. The tools most teams reach for, checklists, walkthroughs, tooltips- were built to teach users the product. AI makes a different approach possible: the product does the work, and the user gets the outcome. That shift touches everything downstream: onboarding, activation, experimentation, even how you read demand.

This session lays out the practical version of that shift: five moves, from capturing intent at sign-up to killing the click tax (every in-app step that doesn't move a user toward their goal), plus the questions the audience pushed hardest on.

PLG solved access. The agentic shift wins activation.

Start with what we know works. PLG solved access: anyone can sign up, the salesperson is no longer the gatekeeper. But PLG removed the salesperson and kept the complexity, then handed it to the user. For anything more sophisticated than a notepad, that complexity quietly kills activation.

The clearest way to see what changes is the progression in how software helps:

• "Tell me": docs and support. The user does all the work.

• "Show me": PLG, self-serve and checklists. Guided, but the user still does the work.

• "Do it for me": PLG + AI. The agent does the job, inside the live product.

And users are already there. Across B2B SaaS deployments, when you compare how many users ask the agent questions versus how many ask it to do things, 70 to 80% of users go to the agent to get work done. Only 10 to 20% come to ask questions. These are not early-adopter audiences. Half a billion people now use AI every day, and they've learned it can act, not just answer.

The line that anchored the whole session: PLG + AI is a multiplier, not a replacement. The user owns the "what." The product owns the "how."

So what is an agentic interface?

It's the layer where the user says what they want, and the agent does it, on top of the product you already have. Your existing features, data, and permissions; nothing replaced. That's the surface the next five moves run on.

The playbook: five moves

1. Capture intent before the first click

The most under-used moment in onboarding is the sign-up flow itself.

The sign-up flow isn't a form. It's where the agent gets the context to operate on the user's behalf for every interaction after. Ask three things: who are you, what are you here to do, and what does "good" look like. Then deliver against it. A quiz at sign-up is the highest-leverage data you collect: a labeled statement of intent. Context before content.

A question from the audience sharpened this: what about users who don't know what they want? Show them options. The options themselves are education: presenting the outcomes your product can deliver teaches a new user what the tool is designed to do, the way the AI-native products already do at sign-up. And make the options clickable, in the flow or inside the chat. Clicking through a quick choice beats reading and typing every time. One related finding from live deployments: when the agent answers with walls of text, users bail back to the UI. Keep it visual, keep it clickable.

2. Generate the first outcome, not a blank page

The blank page is where activation goes to die. Don't drop a new user on an empty screen. Generate the starting point that matches the intent they just gave you.

The move is builder to editor: the agent generates the 80% baseline, the user fine-tunes the last 20%. It won't be 100% of the outcome, and it doesn't need to be. It launches the user 60 to 80% of the way and shows them, concretely, what your product achieves. Ask it of your own product: what can a user generate here? If the answer is "nothing," that's your single biggest activation opportunity.

3. Experiment in hours, not weeks

The agentic interface isn't only an onboarding surface. It's the fastest experimentation surface your product has.

The old loop of design, build, release, and measure ran in weeks. The new one runs in hours. The trick is to decouple the agent from the release train: the backend stays stable while the experience iterates daily. You can change the visuals, the behavior, and even what "activated" means, instantly. Every experience is a test, not a commitment.

It goes further than tuning what exists. You can ship a feature through the agent before you build its UI. One team with heavy demand for specific data reports skipped the visualization build entirely: the user asks, the agent renders the answer inside the chat, the loop closes. If demand proves out, you build the permanent UI knowing exactly what to build, because users asked for it in their own words.

Fast doesn't mean blind. Three things make speed safe:

• Versioning. Any change to a prompt is a change to code. Version it, and you can roll anything back in one click.

• A golden set. A saved battery of real prompts with expected outcomes. Every change you make, you rerun it: am I getting better at outcomes, or worse? It's also how you evaluate a model swap. If a faster model loses no quality, you just gained speed and margin.

• Guardrails. In practice, true hallucination is rare. Most bad answers trace back to ambiguous content or an unclear prompt, and the eval loop shows you exactly where the knowledge gap is so you can fix it.

4. Measure the demand: clicks whisper, prompts yell

A click heatmap shows where a user got stuck. A prompt states the outcome they actually wanted. Unresolved prompts are labeled demand that sharpen what you build next. You stop guessing and read it in their prompts. Clicks whisper. Prompts yell.

Two live examples from the session. Users of one product kept asking the agent to book a room, a capability that interface didn't have yet. The team saw which customers asked and in what volume, and the roadmap conversation was over. In another, users asked a marketing product "how do I run an A/B test with this?", a feature that didn't exist. That's prioritization by written demand instead of guessed intent.

This also changes who drives growth. When PMs can walk into a roadmap discussion with what users literally asked for, instead of a click trail they had to interpret, every PM becomes a growth PM. Conversational Analytics, in early access, is the surface for reading those signals.

5. Engineer champions on day one

We don't train champions anymore. We engineer them.

Here's the uncomfortable measurement behind this move: in a previous product analytics business, only about 10% of users ever became champions, and most users never discover the depth of the features you already shipped. Tooltips, walkthroughs, and customer success hand-holding didn't close that gap. The product has to produce the outcome itself.

So ground the agent in your product knowledge and best practices, and a day-one user gets expert output without becoming an expert first. A user building an email campaign doesn't know the best practices around preheaders and link counts. The grounded agent does, and bakes them into what it generates. Engineering champions isn't educating users anymore. It's educating the agent to operate your product the best-practice way.

Putting it into practice

Reading the moves is easy. The exercise is mapping your own product to them.

Traditional software makes the user walk a nine-step road to value: click path, empty screen, settings, filters, best practices, visualize, analyze. Every step is click tax plus cognitive load. The agentic path collapses it to four: Persona, Intent, Prompt, Outcome.

So map it. Pick one persona, one job-to-be-done, and lay out the journey from sign-up to first outcome:

The middle column, the click tax today, is where the cognitive load lives, and exactly where the agent acts on the intent you captured at sign-up. (clicktax.ai walks you through the mapping.)

What good looks like

Here's the lift teams see when they get this right, an agentic layer in front of an existing product:

slide-34.png: What teams see: Day-1 retention 57% to 90% (Day-7 40 to 60%, time-to-value under 60s); +344% daily AI-driven actions; feature activation 8% to 86%.

<!-- REVIEW before publish: the slide shows feature activation "8% -> 86%". The repo proof bank / deck README lists Qonto at 8% -> 16%. Confirm which figure is correct (and that each metric is cleared for external use) before this goes live. -->

• Day-1 retention: 57% to 90% (Day-7: 40% to 60%, time-to-value under 60 seconds)

• +344% daily AI-driven actions

• Feature activation: 8% to 86%

One more pattern worth knowing: the correlation runs through engagement. The more users engage with the agentic interface early in a trial, the better the retention. And in one heavy B2B deployment, users who engaged the agent more actually spent more time in the product, not because they were confused, but because they were getting more output from it. Time-in-product went up for the right reasons.

What the audience pushed on

The Q&A was half the session. Four questions worth replaying.

"Why would users still come to my UI if everything goes through MCP?" MCP is a real channel, and a useful one for settings, configuration, and simple actions. But MCP hands the decision-making to whatever model the client is running, and it strips the context your product owns: usage history, outcomes, what your product can actually do. Visualization isn't going away either. Users can't know what to ask until they see something: a trend, a dashboard, a date picker. The richer bet is agent-to-agent, where your product exposes specialized agents that carry their own deep context, and the interface layer holds the user's context and decides what to delegate.

"How do AI-averse users respond?" They click around at first. One team went deliberately aggressive: for the first month or two, the agent opened with a generative play the moment it had a use case. Then they eased off. By then users had built the habit, because they'd learned the agent doesn't just answer questions, it does the work. Habit formation is an experiment like any other.

"What happens to user education?" It becomes more strategic, not less, because the reader changes. Agents now consume your documentation to make decisions, and unlike humans, they read all of it. Education shifts from educating users to educating the agent: describing outcomes, describing what every feature solves, in a format agents can act on. Education teams are becoming AI education teams.

"What's the future of the PLG tool stack?" The checklist-and-walkthrough generation has a problem: when a popup appears, roughly 90% of users dismiss it before reading, because they came to do something. Walkthroughs keep a narrow role in feature discovery, but the shift is from guessing intent out of clicks and page views to reading intent directly. Intent analytics is the replacement.

The playbook in three lines

1. A flexible agentic interface, grounded in your knowledge and your existing backend. It acts; it doesn't just answer.

2. Your fastest experimentation surface: change visuals, behavior, and measurement in hours, and learn from real demand.

3. Activation compounds: capture intent, generate the outcome, measure the prompts, engineer champions on day one.

PLG gets them in. The agent gets them to value.

Mickey Alon - Founder and CEO of Foldspace.ai

Ramli John - Founder of DelightPath