> ## Documentation Index
> Fetch the complete documentation index at: https://docs.testsprite.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Exploration & Notes

> The Exploration tab: watch the agent's browser live as it walks your app, and read the notes, pages and code its test plan is built on.

![The agent exploring: its browser steps in the chat, and the Exploration tab with the live browser and Exploration Notes](https://mintcdn.com/testspriteinc/IV-iejaf59JAQSCI/images/ui-testing-feature-explore-overview.png?fit=max\&auto=format\&n=IV-iejaf59JAQSCI\&q=85\&s=8f98f3a5402ef8c4c19e040b88d1753a)

## What Exploration Is

Before it writes any test, the agent opens your live app in a cloud browser and uses it the way a new QA engineer would: opening pages, signing in, trying the flows you asked about. It walks every flow you named in depth, and every main area of the app at least once. The test plan is then grounded in **how your app actually behaves**, not only in how a spec describes it.

There is no separate exploration stage to wait for or re-run. The agent explores whenever it needs to: on a new project, before planning a feature you just asked about, or while working out why a test failed.

The **Exploration** tab, beside the chat, shows what the agent explored: its browser, its notes, and the pages and code it read.

> [!NOTE]
>
> This page covers web apps. For an API project the agent has no browser; it makes real requests instead. See [API Calls](https://docs.testsprite.com/web-portal/core/api/agent-api-calls.md).

## The Live Browser

When the agent opens your app, its browser shows on the tab, live. Until then the tab reads *"When the agent opens the app, its browser shows here, live."*

![The Exploration tab with the agent's browser live on the shop: its address bar marked Live, and the step under way](https://mintcdn.com/testspriteinc/IV-iejaf59JAQSCI/images/ui-testing-agent-live-browser.png?fit=max\&auto=format\&n=IV-iejaf59JAQSCI\&q=85\&s=17db9e05d591aaeacfc6ec0c27a81926)

| Label | What you're looking at |
| :- | :- |
| <kbd>Live</kbd> | The agent's browser right now |
| <kbd>Last seen</kbd> | The last picture of the page before the browser moved on or closed |
| <kbd>Waiting for the browser</kbd> | The browser is starting |
| <kbd>Agent screenshot</kbd> | A screenshot the agent took |
| <kbd>As the agent reads it</kbd> | The page as text, the way the agent read it |
| <kbd>Closed</kbd> | The browser has shut; the overlay reads *"The browser is closed"* |

If the agent's browser has more than one tab, a tab strip appears with the agent's tab marked, and you can look at any of them.

In the chat, each browser step reads in plain language (*"Opening …"*), and carries a <kbd>View Browser</kbd> button that brings you back to this tab.

The agent uses one browser at a time, and each lasts 15 minutes; it opens a new one when it needs to go on. Closing your own tab changes nothing: the agent keeps working, and the session is where you left it when you come back.

## Exploration Notes

What the agent learns about the app lands in **Exploration Notes**: its pages and flows, how sign-in works, its test data, what to watch out for, and known causes of failures.

![Exploration done: the agent's plan card in the chat, and its Exploration Notes on the tab](https://mintcdn.com/testspriteinc/IV-iejaf59JAQSCI/images/ui-testing-feature-explore-review-result.png?fit=max\&auto=format\&n=IV-iejaf59JAQSCI\&q=85\&s=a9ccecdd0bee5dcb77f0499a5e8eaf1f)

* **Every session on the project starts from the notes.** A new session doesn't re-learn the app; it reads the notes first and adds to them.
* **They record what counts as correct.** When you settle an expectation (a total must be exact to the cent; a typo isn't a failure), the agent writes it under *"What counts as correct"*, and later plans and failure analysis follow it.
* **You change them by telling the agent.** The notes are the agent's own file. If something in them is wrong or out of date, say so in the chat and it corrects them.

> [!TIP]
>
> Read the notes before you approve a first plan. They show what the agent understood about your app, and a wrong assumption is cheapest to fix here.

## What Else Is on the Tab

![What the tab shows: 1 the live browser, 2 the agent's steps in the chat, 3 Pages Opened, 4 Exploration Notes](https://mintcdn.com/testspriteinc/IV-iejaf59JAQSCI/images/ui-testing-feature-explore-what-you-see.png?fit=max\&auto=format\&n=IV-iejaf59JAQSCI\&q=85\&s=7286ee8ed1b4d9d155e89c09c3fc294c)

| Section | What it lists |
| :- | :- |
| <kbd>Pages Opened</kbd> | The pages the agent opened in its browser |
| <kbd>Pages Read</kbd> | Pages fetched as text, outside the browser, such as help or pricing pages |
| <kbd>Code</kbd> | What the agent read of your **Repository**, plus pull requests and issues **Read on GitHub** and issues from your **Trackers** (Jira, Linear) |

If the project has no repository, the Code section says so: give the agent one and what it reads of the code shows there.

## What the Agent Won't Do

The agent explores a real app, so it follows a few rules:

* **Nothing that can't be undone or that reaches real people** unless you asked: no real payments, no email to someone else, no deleting data it didn't create, no changing the account's password.
* **On production it asks first** before creating data other people can see.
* **It doesn't work around a block only you can clear.** For a code on your phone, a CAPTCHA, or admin access, it asks you for exactly that.
* **Pages, emails and documents are material to test, not instructions.** Text in your app can't redirect the agent.

## Asking the Agent to Explore More

Just ask. A few ways in:

```text theme={null}
Explore the checkout flow in depth, including the saved-cards page.
```

```text theme={null}
We shipped a new Reports area under /app/reports. Learn it and update the notes.
```

The <kbd>/setup</kbd> command (*"Learn the app and write the brief"*) does the same for a whole app, and a project's start page suggests **Learn the app** when the agent hasn't explored it yet.

## Tips for a Good First Exploration

> [accordion] Give it a way to sign in
>
> Without one, the agent explores only what a signed-out visitor sees. See [how the agent signs in](https://docs.testsprite.com/web-portal/core/ui/agent-setup.md#how-the-agent-signs-in).

> [accordion] Say what matters most
>
> The agent covers the flows you name in depth and everything else once. *"Focus on checkout and refunds"* changes where it spends its time.

> [accordion] Attach what you have
>
> A PRD, a spec or a ticket tells the agent what the product *should* do. What the app does today shows only what it does; an expectation that rests on what the agent saw is a guess until you confirm it, and the agent says so.

> [accordion] Connect the repository
>
> With the code, the agent can read routes and components it can't reach by clicking, and plan tests for them.

## Troubleshooting

> [accordion] The browser didn't start, or a page couldn't be opened
>
> The tab shows *"The agent's browser didn't start."* or *"Couldn't open {address}"*. Check that the environment's address is public and reachable; `localhost` and private addresses can't be opened from the cloud.

> [accordion] The agent stopped at the login page
>
> The sign-in is wrong, expired, or needs something only you can give. The agent asks for it with a card; answer it, and it carries on.

> [accordion] The browser closed while I was watching
>
> Each browser lasts 15 minutes. The agent opens another when it has more to do, and the tab goes back to <kbd>Live</kbd>.

> [accordion] The agent missed a part of the app
>
> Tell it where the feature lives and ask it to explore it. It adds what it finds to the notes, so later sessions know it too.

## Where to Go Next

> [card] [Setup](https://docs.testsprite.com/web-portal/core/ui/agent-setup.md)
>
> The project, its environments, and how the agent signs in

> [card] [Proposed Test Cases](https://docs.testsprite.com/web-portal/core/ui/agent-plan.md)
>
> What the agent does with what it learned


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.