BehaviorLab

Autonomous AI users that test real websites and discover UX problems from real user behavior.

Comment

What is BehaviorLab?

BehaviorLab is an autonomous UX testing platform that uses AI users to explore real web applications and discover usability problems from actual user behavior.

Instead of writing a fixed test script such as “click this button, open this page, and submit this form,” BehaviorLab gives an autonomous AI user a goal and lets it decide how to complete that goal.

The core loop is:

Application → Persona → Goal → Autonomous Execution → Behavioral Telemetry → AI UX Analysis → UX Finding

The important idea is that the UX problem is not predefined. It emerges from what the autonomous user actually experiences.

The Problem

Traditional automated tests are very good at checking whether a technical flow works.

But a website can technically work and still provide a confusing or frustrating experience.

A button can be difficult to discover. Navigation can be unclear. Users can hesitate about what to do next. A workflow can technically succeed while still requiring unnecessary effort.

These problems are difficult to capture with simple pass/fail tests.

BehaviorLab focuses on the behavior between those technical steps.

How It Works

A project represents the web application being tested.

BehaviorLab can generate realistic synthetic personas based on the application and its domain. Each persona represents a different type of user with different goals, preferences, and behaviors.

The user then gives a persona a natural-language goal, for example:

Find a budget laptop under $500 and proceed toward checkout.

The agent is not given a predefined sequence of clicks.

It uses the goal to decide what to do in the application, interacts with the website through a real browser, and adapts when it encounters unexpected situations.

During the session, BehaviorLab records behavioral telemetry including actions, navigation, failures, recovery, and the final outcome.

After the run, Gemini analyzes the observed behavior and produces a human-readable UX finding containing:

  • What happened
  • Why it matters
  • The UX principle involved
  • Evidence from the session
  • A recommendation for the product team

This creates a connection between an observed user behavior and the resulting UX recommendation.

Google Cloud Architecture

BehaviorLab was built using Google's agent and AI infrastructure.

  • Google ADK powers the autonomous agent and its tool-driven execution.
  • Vertex AI and Gemini provide the model intelligence for persona generation and behavioral UX analysis.
  • Cloud Run hosts the BehaviorLab backend and the target test application.
  • Firestore stores projects, personas, runs, sessions, behavioral events, and findings.
  • Playwright provides the real browser interaction layer used by the autonomous user.

The system is designed around a separation between the target application, autonomous execution, behavioral data, and AI analysis.

Why BehaviorShop?

BehaviorShop is the e-commerce application used for the demonstration.

It is intentionally only a test application. BehaviorLab is designed around the idea that the same workflow can be applied to other accessible web applications.

The demo shows an AI user receiving a shopping goal, exploring the website, interacting with products, and generating a UX finding from the resulting behavior.

What I Learned

One of the biggest lessons from building BehaviorLab was that autonomous UX testing is different from simply asking an AI to review a website.

The valuable signal comes from the interaction itself.

The agent needs to make decisions, interact with the browser, recover from unexpected situations, and produce observable behavioral evidence. The analysis then needs to be grounded in that evidence instead of generating generic UX advice.

This led me to structure BehaviorLab around the complete loop:

Goal → Behavior → Evidence → Analysis → Finding

Challenges

One of the main challenges was making the system autonomous without turning it into a hardcoded test script.

The agent needs enough tools and context to operate a browser while still being free to decide how to achieve the user's goal.

Another challenge was separating real behavioral evidence from technical automation errors. A failed browser action does not automatically mean there is a UX problem. BehaviorLab therefore uses the surrounding user behavior, recovery, and session context when generating findings.

I also had to make the system reliable enough to run on Google Cloud while maintaining persistent state for projects, personas, sessions, events, and findings.

Future

The next step is to close the UX improvement loop.

Today:

Discover → Analyze → Recommend

The future direction is:

Discover → Analyze → Recommend → Auto-Fix → Re-run → Verify

BehaviorLab could eventually turn a UX finding into a suggested code change, allow the product team to review it, and then run the synthetic users again to verify whether the experience actually improved.

I also want to add an improvement assistant that allows a team to select a finding and ask what should be changed, why it should be changed, and how the improvement can be verified.

The long-term vision is not just an AI that reports UX problems, but an autonomous system that helps teams discover, improve, and verify better user experiences.

Share this project:

Updates

Submission history