Your product activation rate is a function of the first 30 minutes, not your feature list.
Users sign up. 60% never return. Of the ones who do, 40% never use the key feature. The feature works. The onboarding doesn't.
A onboarding video is a static artifact. A tutorial is a scripted path. An agent is different. An agent adapts to where the user is stuck, uses their data, answers their question, and moves them forward one step. That's what onboarding should have been all along.
This module is 90 minutes of building an onboarding agent that adapts. By the end:
- An agent that reads a new user's state and chooses the next step.
- A measurement loop: are users hitting activation faster?
- A fallback: the agent knows when to hand off to your help center.
Thinker.
Onboarding is not a video. It is not a tour. It is a state machine.
- Every user has a state. Steps completed, data imported, teammates invited.
- Every state has a next-best action. Sometimes obvious, sometimes personal.
- Every next action needs unblocking. Data, context, permissions, guidance.
Agents are good at picking the next action given state. That's exactly what onboarding needs.
The first-30-minutes model
Your job is not "onboarding complete." Your job is "user had one moment in the first 30 minutes where they saw the product do something they cared about." That moment = activation.
The agent's single goal: get the user to that moment as fast as possible, given where they are.
What onboarding agents are not
- Not chatbots that answer "how do I X." That's support.
- Not video narrators. They're decision-makers.
- Not sales pitches. The user already signed up.
Talker.
The onboarding prompt
You are an onboarding agent for [product]. Your single goal
is to get the user to their activation moment: [describe
activation for this product].
Read the user state. Pick one next action. Write a short
message that:
- Names what they've done (1 sentence, positive).
- Names what's next (1 sentence, specific).
- Gives them the path: a button, a link, a doc, a command.
- Asks zero open-ended questions.
Rules:
- Never congratulate on minor steps. Only activation.
- If the user has been stuck for > 10 minutes, escalate.
- If their state is incompatible with activation (e.g., no
integration available), pivot to the closest available
value and flag for follow-up.
Return JSON:
- message: what to show the user
- action: { type: "link"|"button"|"command", target: "..." }
- next_state: what state to expect after this action
User state: [paste state JSON]
Activation definition: [paste]The prompt is terse because onboarding messages are terse. Rambling agents are bad onboarding agents.
Rememberer.
The user's state is the memory. Structure it carefully.
user_state = {
"user_id": "...",
"signed_up_at": "...",
"account_type": "...",
"team_size": ...,
"integrations_connected": [...],
"data_imported": false,
"first_report_created": false,
"activation_moment": null, # timestamp when hit
"steps_completed": [...],
"steps_attempted_and_failed": [...],
"last_message_sent": "...",
"last_active_at": "..."
}State vs. events
Two tables: user_states (the current snapshot) and user_events (the log). The agent reads state; the log is for you to audit.
The activation timestamp
When the user hits the activation moment, stamp it. That's the metric that matters. Time-to-activation per user. Plot it. Trend it. Optimize it.
Doer.
Twelve minutes. Ship a real onboarding agent for one state transition.
Step 1. Define activation (2 min)
One sentence. "User activates when they [action] with [data] producing [outcome]." If you can't write this, onboarding has bigger problems than an agent can solve.
Step 2. List the three states (3 min)
Pre-activation states your users actually hit. Example: (a) just signed up, (b) connected data but haven't created, (c) created but haven't shared with team.
Step 3. Write the state→message logic (3 min)
For each state, what does the agent say and what action does it propose? Keep it to 40 words per message.
Step 4. Wire into your product (3 min)
Simplest path: on user login, read state, call the agent, show the message in a dashboard panel or a modal. If you have email, send via email instead of in-app. Start with one channel.
Step 5. Measure (1 min)
Add one metric: time-to-activation, bucketed by week. Baseline it. Check in 4 weeks.
An agent that picks the next step. One shipped surface. A baseline you can improve.
- Agent messages are too long: your prompt doesn't cap length. Add "under 40 words" explicitly.
- Agent recommends steps users already did: state is stale. Update state on every action, not on a cron.
- Nothing moves the needle: activation is mis-defined. Fix that first. An agent can't fix a bad metric.
Rookie.
Failure 1. Onboarding as a chat
You make the agent conversational. Users type back. Now you're running a support-quality chat. Most users bail after two messages.
Fix: agent proposes. User acts. Agent reads new state. Loop. No open-ended chat in onboarding.
Failure 2. Optimizing steps, not activation
You celebrate "85% of users completed step 3." You shipped a good onboarding. Except time-to-activation didn't move. Steps became a ritual, not a path.
Fix: only measure activation. Steps are instruments, not outcomes.
Failure 3. No escape
User stuck. Agent keeps proposing the same next action. User gives up.
Fix: after two failures on the same step, escalate to a human. Someone from support writes back within a day. That user is twice as likely to activate.
Manager.
Onboarding agents work across product, growth, and success teams. Ownership matters.
Who owns
- Growth: owns activation definition, measurement.
- Product: owns the state machine and the product surfaces.
- Success: owns the human escalation path.
One agent, three owners. A weekly sync keeps them aligned. A monthly review tunes the prompt.
The tuning loop
Every month:
- Read 50 random agent messages.
- Read the 10 users who failed to activate.
- Tune the prompt or the state definitions.
This is product work. Treat it like product work.
Chief.
Risk 1. The activation blind spot
A good onboarding agent moves activation. It doesn't move retention. The user activates, then churns, because the product has issues the agent can't solve.
Governance: always track activation AND 30-day retention. If activation rises but retention doesn't, the product has the problem, not the onboarding.
Risk 2. The false sense of help
Agents make users feel attended to even when the product is broken. That's good for short-term satisfaction, bad for long-term truth.
Governance: every "escalation to human" is data. If escalations spike on the same step, that step is broken. Fix the step, not the agent.
Risk 3. Personalization vs. compliance
Onboarding agents use user data to personalize. In regulated industries, some of that data can't travel through an LLM.
Governance: the data policy from Module 024 applies. Scrub or hash sensitive fields before passing to the agent.
Founder.
Solo founder: the onboarding agent is probably the single highest-ROI agent you can build.
The solo stack
- Define activation (1 sentence).
- Build the agent (this module, 12 min).
- Ship on one surface (email, dashboard, in-app panel).
- Measure time-to-activation weekly.
- Every week, read 5 failed activations. Tune.
The compounding
A 10% improvement in activation rate is worth more than a new feature, for most early-stage products. An agent that improves activation is the rare shipped thing where impact keeps compounding for months.
Onboarding is a state machine. The agent picks the next state.
Everything else (videos, tours, tooltips) is noise. Define activation, track state, run the agent, measure time-to-activation. Everything that doesn't move that number is decoration.