# AI and third parties

> Sequential's AI features send session digests to TypeSafe. This page lists what TypeSafe receives, what your pages load, and what you control.

> **In short**
>
> - TypeSafe receives data. Its model is the judge. Sequential's server makes every call.
> - The judge reads a short text digest of a session. It never receives a recording, heatmap counts or the heatmap picture.
> - For fix briefs, and when an agent reads session data through an access token, the judge also reads short parts of visitor text. It checks them for instructions to an AI. For an agent, it also checks the labels of a custom rubric. When an agent reads heatmap pages, the judge reads the page addresses and the dashboard links in the answer.
> - When a token reads findings, the judge also reads the reason of each finding's newest verdict. Someone on your team typed this reason. In the findings list, the judge also reads the page route of each finding.
> - Sequential removes the user id and personal-looking property names from a digest. It cuts page URLs and full URLs to their path. The **Insights** tab removes less.
> - With Sequential's SDK, your pages load scripts only from Sequential.
> - An agent that you connect, such as claude.ai, receives the answers to its tool calls and Sequential's fixed tool descriptions and server instructions. Anthropic runs claude.ai.

## Who receives what

This page calls TypeSafe's AI model the judge. Nothing on your website contacts TypeSafe.

| Feature | Sent to | What is sent |
|---|---|---|
| [Watch](/docs/watch) (background judging) | TypeSafe | One session digest and your rubric's questions |
| **Insights** tab in the replay player | TypeSafe | A digest built in the browser of the person watching, and your rubric's questions |
| [Ask](/docs/ask) | TypeSafe | Up to 200 session digests, and your description |
| [Ask](/docs/ask) from an agent (`ask_sessions`) | TypeSafe | Up to 50 session digests per call, and the agent's description. In these digests, an element event is named only `element`, with no text, and a custom event has no properties |
| **Try it** in the rubric editor | TypeSafe | One session's digest, and your draft questions |
| **Dashboard** key actions and failures | TypeSafe | The names of up to 60 of your project's most frequent custom events. No counts, users or values |
| Fix briefs ([Privacy at a glance](/docs/privacy-overview)) | TypeSafe | Up to 40 quoted passages of a brief, each up to 200 characters, one question each |
| Session tools and `ask_sessions` for agents ([Privacy at a glance](/docs/privacy-overview)) | TypeSafe | The visitor text and custom rubric labels in the answer, in parts of up to 200 characters, one question each |
| Findings for agents ([Findings and fixes](/docs/findings)) | TypeSafe | The reason of each finding's newest verdict, in parts of up to 200 characters, one question each |
| Heatmap tools for agents (`list_heatmap_pages`, `get_heatmap`), on a Sequential server that has them | TypeSafe | The page addresses (host and path) and the dashboard links in the answer, in parts of up to 200 characters, one question each. No counts, element paths or picture |
| An agent that you connect, for example claude.ai ([Connect claude.ai](/docs/connect-claude-ai)) | The agent's provider. For claude.ai, that is Anthropic | The answers to the agent's tool calls, and Sequential's fixed tool descriptions and server instructions. No other data |
| **Ask your agent** in the replay player and DevTools ([Find and replay sessions](/docs/sessions-and-replay)) | The app you open, and its provider, once you send the prompt there. For **ChatGPT**, OpenAI, when the tab opens | The session id, the time in the session, the page's path without ids, query or fragment, and from DevTools one redacted error message of up to 200 characters. Sequential sends nothing: your browser opens the app with the prompt filled in. With **ChatGPT**, the prompt is in the page address, so your browser sends it to chatgpt.com, and so to OpenAI, when the tab opens, before you send it |
| **Ask your agent about this day** in the Events point panel ([Explore events on the Events page](/docs/events-explorer)) | The app you open, and its provider, once you send the prompt there. For **ChatGPT**, OpenAI, when the tab opens | The date (and hour), per day or per hour, the change in % and what it was compared with, and whether a filter is set. As observed user data: the event type you chose in **Show**, up to 3 page paths without ids, query or fragment, and the newest release version with its time. No other filter value, no user, no session id and no counts. Sequential sends nothing: your browser opens the app with the prompt filled in |
| **Draft a fix**, **Send to your webhook** ([Findings and fixes](/docs/findings)) | The webhook address an owner or admin set for the project | The finding number, the brief's revision and template version, the finding's address in Sequential, and the screened fix brief. Signed, sent once per click. Not on Sequential's hosted service yet |

## What the judge receives

The judge never receives a recording, heatmap counts or the heatmap picture. When an agent reads heatmap pages, the agent screen reads the page addresses (host and path) and the dashboard links. See **What the agent screen receives** below. To judge a session, the judge reads a digest: a short text summary of that session. For Watch, Ask and **Try it**, Sequential builds the digest on its server from your stored events.

Sequential removes from the digest:

- **The user id.** The digest says only "identified" or "anonymous".
- **Domains, query strings and fragments.** Sequential cuts page URLs and full URLs in other text to their path.
- **Properties with personal-looking names**, such as `billing_email` and `firstName`. This page calls this the name filter.

Sequential does not store the digest. It keeps the answers ([Judgments](/docs/judgments)).

> **The Insights tab sends more**
>
> The **Insights** tab builds its own digest in the browser of the person watching. Its digest keeps domains. It sends full URLs inside values as they are. It does not apply the name filter, so it sends a property such as `user_id` on a custom event.

## What the agent screen receives

When an agent uses `get_session`, a `sessions:explore` tool, `ask_sessions`, an `analytics:read` tool, `link_fix` or `get_verification`, Sequential asks the judge whether text in the answer reads as an instruction to an AI. For the analytics tools, this is the event text in the answer, for example event names, page addresses, selectors and property values. For the session tools, this is visitor text: text that a visitor's browser or app sent to Sequential. It also includes the labels of a custom rubric, if the answer has them, and from 11 October 2026 the question text, criteria and phrases of a custom rubric in the answer of `get_rubric`. For `link_fix` and `get_verification`, it is also the text of fix links and release markers. A token's GET `/api/findings/:n/verification` runs `get_verification`, so it is screened too.

The judge receives:

- each part of the visitor text, up to 200 characters: page paths, routes, release names, and browser and operating system names
- for `get_session_timeline`, `list_errors` and `get_overview`, also the names of custom events, error messages and types, top stack frames, and the method, host and route of failed requests. Element text is withheld from these answers, so the judge does not receive it
- for `ask_sessions`, the label of each matched moment: the event text that the judge read, for example an error message. The label of a click, a form submit or another element event is withheld
- the question, option and level labels of a custom rubric in the answer of a session tool or `ask_sessions`. It gets each label, and also all the labels of the answer joined together
- from 11 October 2026, for `get_rubric`, also the question text, criteria and phrases of a custom rubric
- for `link_fix` and `get_verification`, also each part of the fix link addresses, release names, environments and commit SHAs. See [Findings and fixes](/docs/findings)
- when an agent reads heatmap pages (`list_heatmap_pages`, `get_heatmap`, on a Sequential server that has them), each page address (host and path) and each dashboard link in the answer. It never receives the heatmap counts, the element paths or the picture
- a fixed question and a fixed description of the text

The judge does not receive:

- session ids, user ids, account ids, event ids, rubric ids or option keys
- the text and criteria of your rubric's questions, except in the answer of `get_rubric` from 11 October 2026
- the labels and text of the shipped default rubric. After **Reset to default**, it can receive them too
- times, counts or judgments

When a token reads the findings list or one finding, the judge also receives the reason of each finding's newest verdict. This is GET `/api/findings` or `/api/findings/:n`, or the `list_findings` or `get_finding` tool. For the findings list, the judge also receives the `scope` and `page_route` of each finding, up to 200 characters each. The judge never receives the name of the person who gave the verdict. The agent never gets that name either.

Sequential redacts the text before it sends it: email addresses, tokens and card numbers. From 10 October 2026, it also removes the names, emails and phone numbers of the known people of your project, so the judge does not receive them either. See [Privacy at a glance](/docs/privacy-overview#names-emails-and-phone-numbers). If the screen cannot run, the agent does not get the text. A token does not get a fix brief or a finding that Sequential could not screen, unless the operator sets `FINDINGS_SCREEN_REQUIRED=false`. When the brief screen is paused, a token gets them with every quoted passage withheld. Ids are not sent to the judge. The agent gets them marked as `{"id": "…", "source": "observed"}`. See [Privacy at a glance](/docs/privacy-overview).

## What your pages load

With Sequential's own SDK, every script your pages load comes from Sequential, not from another company's servers. If you use another vendor's SDK, that SDK's code also runs on your pages.

## What you control

**Background judging.** It is on by default for each project. Owners and admins change it under **Settings** → **Projects** → your project → **Insights**, with the switch **Judge new sessions automatically**. Members and viewers see the switch, but they cannot change it. Your Sequential server must also allow it: whoever runs the server sets `JUDGING_AUTOMATIC=on`. While background judging is off, Watch tells you why, and Sequential sends nothing in the background. See [Watch](/docs/watch).

**On-demand features.** If the server has them set up, no project setting turns them off. The background judging switch does not stop them either. Roles decide who can use each one ([Roles and permissions](/docs/roles-and-permissions)).

| Feature | Roles that can use it |
|---|---|
| **Insights** tab, Ask | Owner, Admin, Member, Viewer |
| **Try it** | Owner, Admin |
| Ask from an agent (`ask_sessions`) | An agent with a token that has the scope `ask:use`. Only owners and admins create tokens |

**Personal data.** Sequential sends rubric questions and Ask descriptions as written. The digest carries element text, error messages, custom event names and page paths as written, and Sequential does not check them for emails or card numbers. Keep customers' names, emails and other personal data out of these and out of property values.
- When background judging is turned on, Sequential also sends the unjudged sessions from the previous 7 days to TypeSafe.

## Limits

- **The name filter reads names only, and matches whole words.** Sequential sends a value under an ordinary name as it is, up to 80 characters. It sends `firstname` and `useremail`, because it does not split them into words.
- **In Watch, Ask and Try it, only full URLs lose their domain and query string.** Sequential sends `/signup?ref=nav` and `app.example.com/signup?ref=nav` whole.
- **TypeSafe's own terms** control how it stores and uses what it receives. This page covers what Sequential sends.
- The Sequential app loads its fonts from Google Fonts, so your team's browsers contact Google when they use the app.
- Sequential keeps each Ask description in a log for 180 days.

### When each feature sends data

| Feature | When it sends data |
|---|---|
| Watch (background judging) | At least 30 minutes after a session ends, once per session, and only for projects where background judging is turned on |
| **Insights** tab | When someone opens the tab and no saved judgment matches. Also when someone clicks **Re-run**, at most once every 10 minutes per session. |
| Ask | Each click on **Ask** or **Search N more**, unless the same description over the same sessions was answered in the last hour |
| Ask from an agent | Each call of `ask_sessions`, unless the same description over the same sessions was answered in the last hour |
| **Try it** | Each click on **Run** |
| **Dashboard** key actions and failures | When a new dashboard is set up, or someone adds a **Key actions** or **Failed or abandoned** tile, unless the same event names were judged in the last 7 days |
| Fix briefs | When Sequential delivers a brief, and when an agent reads one finding with `get_finding`. Sequential can use an earlier answer for the same version of the brief, for up to 30 days. If Sequential cannot read the allowance, it sends at most 10 briefs a minute per project from each server process. Past that, it sends nothing and withholds every quoted passage of the brief. |
| Session and analytics tools for agents | Each answer of `get_session`, a `sessions:explore` tool, `ask_sessions` or an `analytics:read` tool that has visitor text, unless Sequential has a recent answer for that text |
| Findings for agents | Each time a token reads the findings list or one finding and a newest verdict has a reason, unless Sequential has a recent answer for that reason |

When background judging is turned on for a project, Sequential also sends the sessions from the previous 7 days that are not judged yet. Whoever runs your Sequential server can also send older sessions. This is called a backfill.

### Session facts and event lines

The digest has facts about the session and up to 255 event lines.

**Session facts:** duration, device type, identified or anonymous, the entry page's path, browser, operating system, country code and the number of pages visited. If the session's recording measured them, the digest also has counts of JavaScript errors, failed requests and console errors ([DevTools in replays](/docs/devtools)).

**Event lines:** up to 255. Each line has its time from the start of the session and the path of the page it happened on.

| Event | What its line carries |
|---|---|
| Page view | The path, such as `/settings/billing`, or a mobile screen name |
| Click, rage click, dead click | The element's text or id, such as "Add card" |
| Form submit | The form's name |
| Error | The error message and its type |
| Custom event | Its name, such as `plan_changed`, and its properties as `key=value` |
| Identify | Only that the visitor was identified. An identify event carries no text. |

Sequential cuts each label to its first line and 60 characters. It cuts a custom event's properties to 80 characters in total.

### How Sequential removes URLs and property names

**URLs.** Sequential cuts page URLs to their path. It also cuts a full URL inside any other text to its path. For example: `https://app.example.com/signup?ref=nav` in a property value.

Inside a label or property value, `https://app.example.com/signup?ref=nav` becomes `/signup`. But Sequential sends `/signup?ref=nav` and `app.example.com/signup?ref=nav` whole. The **Insights** tab keeps full URLs whole too.

**Property names.** Sequential drops a custom-event property in two cases:

- Its name starts with `$`.
- One of the words in its name is exactly one of these: email, mail, phone, tel, password, pass, token, secret, address, addr, name, ip, user, username, account, ssn, iban, card.

Sequential splits a name into words at `_`, `-`, `.`, spaces, and where a lowercase letter or digit is followed by a capital.

- Dropped: `billing_email`, `firstName`, `ip_address`
- Kept: `firstname`, `IPAddress`, `customer_id`, `description`, `zip`

The name filter reads names only. Under an ordinary name, Sequential sends the value as it is, up to 80 characters. For example: `note=call jane@example.com`.

### What reaches the judge from your app and your rubric

From Watch, Ask and **Try it**, the judge receives only what your events contain. From the **Insights** tab, it also receives the text of clicked elements, as the recording captured it. See [Send custom events](/docs/custom-events).

Every call also sends the questions: your project's rubric questions, the draft you edit for **Try it**, or your one-line description for Ask ([Customise the rubric](/docs/rubric)). Owners and admins edit the rubric under **Settings** → **Projects** → your project → **Insights**.

### Feature switches and the name filter

When judging is set up on the server, no project setting turns off the **Insights** tab, Ask or **Try it**. To stop an agent from running Ask, revoke its token or give it a token without `ask:use`. The endpoint `/mcp/readonly` does not stop it.

For property values, do not rely on the name filter. It reads names, not values. The **Insights** tab does not apply it.

### Google Fonts in the Sequential app

The Sequential app loads its fonts from Google Fonts, so your team's browsers contact Google when they use the app. Nothing that Sequential adds to your pages contacts Google.

### How long Sequential keeps the answers

| What | How long Sequential keeps it |
|---|---|
| A session's Watch judgment | 400 days after the session ends |
| An **Insights** judgment | 7 days |
| An Ask answer | 1 hour |
| Each Ask description, in a log, with who asked. For an agent, this is the id of its token | 180 days |
| A screening answer for an agent's tool, or for a verdict reason that a token reads | Up to 7 days, as a keyed hash of the text with a yes or no |

If the server sets a [retention limit](/docs/retention-and-deletion#a-server-wide-limit), Sequential deletes Watch judgments and Ask descriptions sooner.

### What the Insights digest contains

The **Insights** tab builds its digest from the recording and the session's events. Sequential's server removes query strings from the page URLs in this digest. Then the server sends the digest to the judge. Compared with the server digest, the **Insights** digest:

- keeps the domain on the entry page, the referrer and each page view, such as `app.example.com`
- sends the first three properties of each custom event or error as `name=value`, and cuts each value to 40 characters
- skips only properties whose names start with `$` or `[Amplitude]`. It does not apply the name filter.
- does not shorten URLs inside labels or property values. It sends `ref=https://app.example.com/signup?ref=nav` as it is, with the domain and query string.
- adds the element's selector to clicks, rage clicks, dead clicks and form submits
- adds clicks and page views that it finds in the recording. Each click has the element's text as the recording captured it.
- leaves out the error counts

It cuts its labels to 80 characters. Like the server digest, it says only "identified" or "anonymous". See [Session insights](/docs/session-insights).

### Where each script comes from

- The SDK and the open-source recording library that the recorder uses come from Sequential's CDN.
- The recorder comes from Sequential's API.
- Events and recordings go to Sequential's API, not to the CDN ([Sequential SDK](/docs/sequential)).

The **Content-Security-Policy** section of each install page lists every origin your pages load scripts from ([Install Sequential](/docs/install)).

## Related

- [Privacy at a glance](/docs/privacy-overview)
- [Judgments](/docs/judgments)
- [Session insights](/docs/session-insights)
- [Ask: find sessions by describing them](/docs/ask)
- [Customise the rubric](/docs/rubric)
- [What Sequential keeps from page URLs](/docs/url-policy)
- [Masking and redaction](/docs/masking-and-redaction)
- [Retention and deletion](/docs/retention-and-deletion)
- [Roles and permissions](/docs/roles-and-permissions)