Ask, and it shows you
Ask out loud or type. The guide opens the right screen and tab, then lights up the exact control. No tours to write, no selectors to keep alive.
Your product, explained by itself. A guide that learns your UI from its code and points to the exact button.
Users ask by voice or text. Wayfind opens the right screen, lights up the control, and says why something is hidden. It never clicks anything that saves, deletes or costs money.
npx wayfind-setup — or one script tag
This is how your product should explain itself.
Knows why it’s hidden
Every control in the map carries the conditions it renders under — role, plan, feature flag. When something isn’t there, users hear why instead of hunting.
Never clicks the risky part
Anything that saves, deletes or costs money is classed at build time. The guide lights it up and hands the click to your user.
From your code to the exact button.
No recording, no crawling, no CSS selectors. Wayfind reads what your code already says about every control.
your code · Settings.tsx
1<Tabs value={tab}>
2 <Tab onClick={() => setTab("team")}>
3 Team
4 </Tab>
5</Tabs>
6{user.role === "admin" && (
7 <Button
8 onClick={invite}>
9 Invite member
10 </Button>
11)}
1Build
A build plugin stamps a stable ID on every control. IDs survive refactors and copy changes, so links never rot.
wayfind.map.json
team.invite-member
screen
/settings
revealedBy
settings.tab-team
gate
user.role === "admin"
risk
commit · user clicks
Labels, routes and conditions only. No source code.
2Map
The indexer records every screen, the tab or dialog that reveals each control, who is allowed to see it, and how risky it is.
your app · /settings
Settings
GeneralTeamBilling
Workspace
Invite member
3Guide
Users ask in words. The guide answers from the map, opens the way, and lights the exact control in your live UI.
Never stale. Your CI rebuilds the map on every deploy, so the guide always describes the UI your users actually have.
Talk to it. It answers in a second or two.
Realtime voice, in your app. Start talking and it stops to listen. Most answers need no lookup, because every screen change hands the guide a short card of what’s on it.
When it helps, it can glance at the screen — to read a chart title or an error your code didn’t predict. Frames are read as content, never as instructions, and every action still needs an ID from your map.
Prefer typing? Same guide, same map.
Safe by design, not by prompt.
Clicks only what’s provably UI
Tabs, menus, navigation. Every control is classed at build time; anything that commits, deletes or charges is left for your user.
Sensitive fields stay empty
Passwords, card numbers and API keys are marked in the map. The guide will point to them, never fill them.
Takes instructions only from your code
The model works from text written in your code and the list of controls on screen. Page text isn’t sent, so a hostile comment can’t steer it. With vision on, frames are read as content, never as instructions.
Only the map leaves your CI
Indexing runs in your own build. We receive labels, routes, conditions and risk classes. Your source code stays with you.
Who clicks what
| Class | Examples | Who clicks |
|---|---|---|
| safe | Tabs, menus, navigation | Guide may click |
| commit | Save, send, invite | Your user clicks |
| destructive | Delete, archive | Your user clicks |
| financial | Upgrade, pay, refund | Your user clicks |
| sensitive | Passwords, cards, keys | Never filled |
Classed automatically from what each control’s handler does. You review it, and can override any control.
Measured, not promised.
From our own test on a 31,000-line Electron app.
- to index the whole app
- <0.5 sto index the whole app
- real user questions answered correctly
- 14/15real user questions answered correctly
- unsafe clicks
- 0unsafe clicks
- invented features
- 0invented features
- from question to spoken reply
- 1–2 sfrom question to spoken reply
An honest comparison. Each approach has its place.
How it learns your UI
- Product tours
- Steps recorded by hand
- Digital adoption platforms
- Captured in a visual editor
- Browser agents
- Reads the page every time
- Wayfind
- From your code, at build time
Explains hidden or locked UI
- Product tours
- No
- Digital adoption platforms
- Only rules you configure
- Browser agents
- Can’t see what isn’t rendered
- Wayfind
- Knows the role, flag or tab behind it
Voice conversation
- Product tours
- No
- Digital adoption platforms
- Rarely
- Browser agents
- Some
- Wayfind
- Realtime, replies in ~1–2 s
Acting safely
- Product tours
- Doesn’t act
- Digital adoption platforms
- Scripted automations
- Browser agents
- Clicks what it can reach; page text can steer it
- Wayfind
- Clicks only safe UI, hands you the rest
Upkeep when the UI changes
- Product tours
- Re-record the tour
- Digital adoption platforms
- Fix broken selectors
- Browser agents
- None, but slower and less predictable
- Wayfind
- Map rebuilds on every deploy
Two ways in. Pick how deep to go.
One command
Run it in your repo. It opens a branch with everything wired: the build plugin, a CI step, the connector for roles and flags, and your first map. Review it like any pull request.
One script tag
No build access? Paste one tag into any web app and the guide learns from the live page. Desktop apps (Electron, Tauri) use the command.
index.html · before </body>
<script
src="https://wayfind.dev/sdk/v1/wayfind.js"
data-key="YOUR_PUBLISHABLE_KEY"
defer
></script>Learns controls from the live page — names, roles, headings, URLs. Add code mode later for hidden UI, permissions and risk classes.
Start free. Pay as it gets used.
Every plan includes voice, both install modes, and the same safety rules.
Starter
Try it on one app.
$0
- 300 guided sessions / mo
- 30 voice minutes
- 1 project
- Script mode and code mode
- Wayfind badge
Growth
For a product with real users.
$149/mo
- 5,000 guided sessions / mo
- 1,000 voice minutes
- 3 projects
- Analytics
- No-code overrides editor
- No badge
Scale
For teams shipping every day.
$599/mo
- 30,000 guided sessions / mo
- 6,000 voice minutes
- 10 projects
- Team roles
- CI map history and diffs
- Priority support
Enterprise
For security reviews and scale.
Custom
- Custom sessions and voice
- Unlimited projects
- SSO / SAML
- Self-hosted option
- DPA and data residency
Questions, answered.
Do you ever see our source code?
No. Indexing runs in your own build and CI, and only the map is uploaded: labels, routes, render conditions and risk classes. One thing to know: the npx wayfind-setup installer uses an AI assistant (Claude) on your machine to wire up the connector, and it reads your code once while doing that.
Which apps does it work with?
Web apps and desktop apps. Code mode supports React, Next.js, Vite, Electron and Tauri. Script mode works on any web app with a single tag, learning controls from the live page.
What happens when our UI changes?
Your CI rebuilds the map on every deploy. IDs describe what a control is, not where it sits, so a renamed button keeps its ID and nothing you’ve configured breaks.
Can the guide click things by itself?
Only safe ones: tabs, menus, navigation, dialogs that just open. Anything classed as commit, destructive or financial is lit up for your user to click, and sensitive fields are never filled. You can change any control’s class.
How does it know what a user is allowed to see?
Each control in the map carries the conditions it renders under, like user.role === "admin" or a feature flag. Your app tells the guide the current user’s role, plan and flags — nothing personal — so it can explain instead of guessing.
Do we have to use voice?
No. Text works everywhere, and voice can be turned off per project. When it’s on, replies typically start within one to two seconds.
Can we self-host?
Yes, on Enterprise — along with SSO/SAML, a DPA and data residency. Talk to us and we’ll walk through your setup.
Let your product explain itself.
Free for your first project. One command or one tag to install.