Find the UX bugs before your users do.
AI agents navigate your product flow and flag where it breaks or confuses. Point InsightLab at a staging URL, a preview deploy, or localhost; the agents attempt the task you name, get stuck where your real users would, and hand back severity-ranked findings with the replay behind each one. Run it from your terminal, your test suite, or straight inside Claude Code, Cursor, and Codex.
Wherever you already work.
Same engine behind all four. Start in the browser, wire it into your terminal and CI, import it into your own code, or let your coding agent call it directly.
Browser
Paste a URL, name the flow and the audience, and read the findings with the replay next to them.
Open the demoCLI
Test a preview deploy on every pull request. Exits non-zero when a Critical finding lands, so CI can hold the merge.
npm install -g @insightlabai.dev/cli insightlab run $PREVIEW_URL \ --task "complete checkout" \ --fail-on critical
SDK
Call it from your own code or test suite. Typed client, ESM and CommonJS, findings you can assert on.
npm install @insightlabai.dev/sdk
const { findings } = await il.run({
url, task: "complete checkout",
});MCP server
Claude Code, Cursor, and Codex call InsightLab themselves. Your agent writes the UI, finds out where it breaks, and fixes it without leaving the editor.
{
"mcpServers": {
"insightlab": {
"command": "npx",
"args": ["-y", "@insightlabai.dev/mcp"],
"env": {
"INSIGHTLAB_API_KEY": "il_live_..."
}
}
}
}Prefer to call it directly? The REST API takes a target, an audience, and the tasks to attempt, then returns a run id you can poll for findings.
Every finding shows its work.
An AI that hands you a bug list is only useful if you can check it. Each run ships with what was actually observed, what was inferred, and what is still unknown, so you can tell a real problem from a confident guess before you open the editor.
Open the demoPoint it at a build. Get back a fix list.
AI agents navigate the flow and flag every place it breaks or confuses. Four steps from a URL to something you can act on in the same sitting.
Give it a build
A staging URL, a preview deploy, localhost, or a Figma prototype when the code does not exist yet. Screenshots work for a static flow.
Name the flow and the users
Say what they should accomplish and who they are. Impatient first-timers and careful returning users fail in different places.
Agents walk it for real
Each synthetic user drives an actual browser against your target, and the run records where they hesitate, backtrack, and give up.
Read the findings
Each issue carries a severity, how many agents hit it, and the replay of the moment it happened, so you can go straight to the code.
Your PM and designer get the same run, without the terminal.
The findings you pull from the CLI open in a full study workspace: a planner for setting up the audience and tasks, session replays per synthetic user, and a report your team can read without knowing what a preview deploy is. Same run, same evidence, no handoff.
Explore use casesYou already test the code. This tests the experience.
Your suite proves the button fires the right event. It cannot tell you nobody found the button. That gap is where usability bugs live, and it usually stays open until a real user falls into it.
Nothing to recruit or schedule
No participant calendars, no design partner waiting on a build. A run starts the moment you have a URL, which means you can test the branch instead of the release.
Different users break it differently
An impatient first-timer and a careful returning user fail in different places. Several archetypes walk the same flow in one run, so you see both without booking two sessions.
Cheap enough to run on a branch
Live user testing is expensive enough that you save it for the big release. This is cheap enough to point at a pull request, which is when a fix still costs you nothing.
Evidence, not vibes
Every finding carries the replay it came from, how many agents hit it, and what the run assumed. When it is unsure, it says so instead of inventing a confident bug report.
Common questions
Preview deploys and any URL the runner can reach work directly. A local dev server needs to be reachable too, so either run the CLI where the server is running or expose it through a tunnel. For targets behind a login, pass credentials to the run and the agents will authenticate before starting the task.
Yes. The CLI takes an API key from the environment and exits non-zero when a finding lands at or above the severity you set with --fail-on, so a Critical usability regression can block a merge the same way a failing test does. Runs take minutes rather than seconds, so most teams point it at the flows that matter most instead of every route.
It exposes the run as a tool, so Claude Code, Cursor, or Codex can start a test, poll it, and read the findings back without you switching windows. The useful part is the loop: your agent builds a flow, tests it, sees which synthetic users got stuck and where, and fixes it before you ever look at the diff.
InsightLab runs directional synthetic-user simulations, not direct measurements from live users. Every recommendation is paired with evidence, confidence, assumptions, and provenance so your team can see how much weight to give the finding.
A target and a task. The target is a URL, a Figma prototype if the code does not exist yet, or screenshots for a static flow. The task is what a user should accomplish, plus a sentence on who they are. Everything else, including which metrics matter for your kind of product, is selected for you and shown in the report so you can see why.
No. InsightLab helps narrow questions and surface likely friction before a live validation round. Live user research and post-launch measurement remain important for final confirmation.
Most runs finish in under 6 minutes. From the CLI or MCP it is one command and the run streams progress until it exits. In the browser, setup takes about 2 minutes and the run continues in the background, so you can close the tab and come back for the results.
Study context is scoped to your workspace, encrypted in transit and at rest, and deletable on request. PII in optional source context can be excluded or anonymized before a run. See the Security page for a full breakdown. Security page.
InsightLab selects metrics from a controlled catalog rather than generating them arbitrarily. Universal metrics apply across studies, while vertical-specific metrics are added after automatic vertical detection. The demo shows why each metric was selected and which source signals informed that choice.
Each Trust Report surfaces the relevant behavioral metrics, replay-backed findings, evidence for each recommendation, confidence, assumptions, provenance, and whether the finding is ready to support a business impact claim.
Synthetic users are generated from the study brief and selected source context across Scrappy Hackers, Risk-Averse Scalers, and ROI Maximizers. A single run can surface how different user archetypes respond to the same flow, and the replay lets you inspect the simulated path behind the summary.
Surveys and NPS capture stated preferences. InsightLab simulates task behavior against a concrete flow, then shows replay evidence, metric movement, and trust context for each recommendation.
Yes. Choose Figma URL as the study source, add the task and audience, review the automatically selected metrics, then generate synthetic users from that prototype context. In demo mode, the replay does not render interactive Figma frames.
A recommendation points back to the replay, selected behavioral metrics, and the assumptions used to interpret the simulated run. Provenance is included so the report explains why it recommends something.
InsightLab combines source selection, automatic vertical detection, controlled behavioral metrics, synthetic-user generation, simulation replay, insights, and a Trust Report in one flow. The recommendation is not just a summary; it explains its evidence and limits.
Point it at your
own flow.
Run it against a build you already have and see what your users would have hit. If you would rather be walked through it, we are happy to do that instead.