Conversations, Responses & Context

This page covers how AgentQ processes your messages and what happens during a response. It also explains how context from your current page is injected automatically and how AgentQ manages long conversations.

Starting a Conversation

Type your request in the message box at the bottom of the chat and press Enter to send it. Here are some examples of what you can ask:

Smart Suggestions

When you open a new conversation, AgentQ generates 3 personalized prompt suggestions based on your data assets. The suggestions are not static. They are tailored to the containers in your workspace with the most active anomalies, so the prompts are immediately useful instead of generic.

Suggestions are designed around the 5 guided workflow tools: investigating anomalies, analyzing trends, interpreting quality scores, generating quality checks, and transforming datasets. These appear as Workflow steps in the response, and each suggestion is formatted with explicit container and datastore names so you can send it directly without editing.

The suggestions render as a single-view carousel labeled Suggested prompts above the message input. Navigate with the left and right chevrons, jump directly with the indicator dots, and use the X of Y counter to see where you are in the list. Clicking a suggestion sends it immediately as your message; there is no separate "confirm" step.

When the chat is opened with a specific asset in context (a badge above the input), the carousel is hidden so it does not compete with the scoped question you already came here to ask. Suggestions also disappear once the conversation has messages, and reappear when you start a new session.

Understanding Responses

When AgentQ processes your request, you see its progress unfold in three phases:

1. Thinking. AgentQ analyzes your message, decides which tools to call, and builds an execution plan. A "Thinking..." indicator appears while this happens.
2. Tool execution. Each action it takes appears as an expandable step labeled with the operation name (for example, Quality Scores, List Quality Checks, Create Quality Check). Click any step to see the exact input parameters sent and the raw output returned.
3. Response. The final answer is rendered in Markdown with tables, code blocks, and formatted text as appropriate.

You can continue the conversation to refine results, ask follow-up questions, or request additional actions.

Tool Step Labels

The step labels you see during a response correspond to specific platform operations. The table below covers the most common labels for exploration, quality checks, insights, and guided workflows:

Tool Call Timeline

While AgentQ works, every tool step for the current response is grouped into a single Used N tool(s) timeline above the response.

• The timeline auto-expands during streaming so you can watch each step run, then auto-collapses about one second after the response finishes. Click the timeline to reopen it at any time.
• Each step shows a status dot: a subtle animation while the step is running, and a filled dot after it completes. The completion color reflects the outcome (success, warning for partial results, or negative for a failure).
• Expanding a completed step reveals a Results panel with the Input the agent sent and the Output it received. Long outputs are shortened and end with a ... (truncated) marker. Scrolling reveals what fits in the panel, not the removed portion. If you need the full output, ask AgentQ to summarize or repeat the specific detail.

Answer Basis

Answers that AgentQ produces by running tools normally end with a short Answer basis note stating how the answer was produced:

The Derived answer label also covers a lighter case. A reply that drew on more than one listing tool, or that paged the same listing more than once, is labeled derived even when the reasoning over those results was simple. A routine exploration that lists datastores, then containers, then fields is labeled derived for that reason, which makes the label a common sight rather than a rare warning.

The note can carry two additional lines:

• Method: how the answer was produced. It appears on derived and could-not-verify answers, never on a direct tool result. On a derived answer it describes what AgentQ combined, compared, or calculated, or states that the answer was assembled from several listing results or result pages. On a could-not-verify answer it states that the requested result is not available through the tools.
• Limitations: what keeps the answer from being complete. On a direct answer it appears when the tool reported that more results exist than it returned. A derived answer can carry that same truncation warning, or the completeness risk AgentQ stated for its own approach. On a could-not-verify answer it carries the capability the available tools do not cover. A plain count answered with an exact total carries no Limitations line, even when the list shown alongside it was shortened.

Two kinds of reply carry no note: a purely conversational reply that used no tools, and the reply in which AgentQ pauses to ask for confirmation before a best-effort analysis, since that reply already explains the gap. The note comes back on the answer that follows once you agree.

Because the note is part of the response text, it stays with the message in the conversation history, after a reload, and in copies and PDF exports.

A derived label describes how the answer was built rather than claiming it is wrong. It tells you the result came from AgentQ's own reasoning over one or more tool outputs rather than being returned directly by a tool, so give it the same review you would give an analysis assembled by hand.

Confirmation Before Best-Effort Analyses

Some requests have no tool that answers them directly, and deriving an answer would mean fetching and comparing large amounts of data (for example, comparing every datastore against every schedule, or proving that something never happens). In those cases AgentQ pauses before running that analysis, explains that no tool answers the request directly, and asks whether to proceed. The question sets out the Proposed approach it would take and, where one applies, the Completeness risk that comes with it. AgentQ may already have run a quick lookup while working out what you asked for, so the tool call timeline above the question can show a few completed steps.

• Nothing further runs until you agree. AgentQ closes the question by asking you to reply yes.
• Only a short, direct confirmation is recognized: yes, yes please, yes try it, yes try the proposed derivation, proceed, please proceed, proceed with the proposed derivation, go ahead, go ahead with the proposed derivation, or try it. Capitalization and punctuation do not matter, but other wordings such as sure, ok, or do it are not recognized, and neither is an accepted phrase with extra words added to it, such as yes, go ahead. A reply AgentQ does not recognize does not count as approval, so the analysis does not run and the question comes back.
• The confirmation applies only to the analysis AgentQ just proposed, and only as the next message in that conversation. If you ask anything else first, the offer no longer stands and you have to make the request again. There is no time limit: as long as the proposal is still the last response, a confirmation works after a break or a page reload.
• AgentQ always asks whenever the analysis draws on more than one tool's results, carries a completeness risk it has stated, or its own restatement of the request or of the proposed approach uses wording that points at a wide or absence-based analysis, such as all, every, compare, infer, never, or without. It can also ask on its own initiative when it judges an analysis expensive or open-ended, so even a narrow request can be put to you for approval.
• AgentQ does not ask before every derivation. A narrow calculation over one tool's results runs without a prompt, and a reply that simply drew on several listings is only recognized as derived after the fact. In both cases the answer still carries the Derived answer label, which is your signal to review how it was built.

Asset Cards Below Responses

When AgentQ creates a new asset for you, a clickable card appears below the response with a short caption and the asset name (for example, "Created #341960 • isNotNull" for a quality check, or a small "Operation" caption above a bold "Scan #7741" label for an operation). Clicking the card takes you straight to that asset's page.

Cards cover newly created quality checks, quality check templates, computed tables, computed files, computed joins, computed fields, and completed operations (Sync, Profile, Scan, Export, Materialize). If AgentQ produces more than three cards in one response, only the first three are visible with a + N more button at the end.

Updates to existing assets do not produce cards. The change still appears in the tool call timeline above, and the affected view refreshes automatically (see Auto-Refresh After Responses below).

Deletions do not appear as cards either. When AgentQ removes something you were looking at, it redirects you instead. See When AgentQ deletes what you're viewing below.

Auto-Refresh After Responses

Views tied to the assets AgentQ just changed refresh automatically. You never need to reload the page after a response.

• Newly created or updated assets appear in the affected listings, side panels, and trees as soon as the tool step completes.
• Long-running operations that transition to running also trigger refreshes, so their live status appears without a manual reload.

The refresh is scoped to the surfaces the response affected (only the checks list for a check, only the datastore tree for a container, and so on), not a full-page reload. If you are on a page unrelated to what AgentQ just did, nothing on your side changes.

When AgentQ Deletes What You're Viewing

If the assistant deletes the asset you are currently looking at, Qualytics redirects you to a safe destination so you are not left on a dead page:

The redirect only fires when the deleted asset matches the page you are on. If you navigated away before AgentQ finished the deletion, no redirect happens; the affected listings on your new page still refresh normally.

Message Actions

Each message includes action buttons:

Context-Aware Conversations

AgentQ automatically detects the page you are on and injects the relevant asset context into the conversation. This means you can ask direct questions without repeating which datastore, container, or anomaly you mean.

When you open the floating chat widget from a page, the injected context appears as a badge above the input box (icon plus a short asset label) before you send your message, so you can see exactly what AgentQ is working with.

Conversations Inside the Check and Template Dialogs

Besides the full-page chat and the floating chat, there is a third place conversations live: the assistant panel docked inside the quality check dialog and the check template dialog. Conversations you have there behave differently from the other two surfaces, so it is worth knowing the rules.

Opening the Panel

The panel is opened from a narrow strip of round buttons along the right edge of the dialog. One of them carries the AgentQ mark, and hovering it names the assistant you are about to open, reading Check Assistant in a quality check dialog and Template Assistant in a check template dialog. The strip also holds a button for the description editor. While the panel is open the AgentQ button drops out of the strip, and the top of the strip becomes Hide panel, which closes it again.

You can also widen or narrow the panel by dragging its left edge, on a large enough screen. The width applies to the dialog you are in and returns to the default the next time you open one.

You often do not need to open the panel at all:

• When you open the dialog to create a check or template, the panel is already open.
• When you edit an existing one, the panel starts closed, unless that item already has a conversation, in which case it opens on its own. Because the item's conversations are looked up after the dialog appears, the panel can open a moment after the rest of the form.

Cloning is the exception to the first rule. Clone reshapes the dialog you already have open rather than opening a new one, so the panel keeps whatever state it was in: if it was hidden while you were editing, it stays hidden. The conversation does restart empty, with the wording used for a new check.

Once you show or hide the panel yourself, your choice takes over from those defaults for that dialog type. The check dialog and the template dialog each remember their own choice, so hiding the assistant while working on checks does not hide it for templates. Each preference is remembered by the browser you are using, so it survives reloads and restarts but does not follow you to another browser or device.

The one exception is a workspace where AgentQ has not been set up yet. There the panel stays closed when you edit an existing check or template, whatever you chose last, and you open it yourself if you want the link to the setup screen.

Before your first message the panel offers two starter prompts. Selecting one sends it straight away. The prompts change depending on whether you are creating or editing, and most also differ between the check and the template dialog.

One Conversation Per Item

A conversation held in this panel belongs to the item it was opened from, and to you. Reopening that item's dialog restores the most recently updated conversation you had about it, with the earlier messages already in place. A colleague opening the same check sees their own conversations, never yours.

Creating a new check or template is the exception, because the item does not exist yet. Until you save, that conversation is an ordinary AgentQ chat and appears in your Chats list like any other. When you click Save, it becomes attached to the check or template you just created, and from then on it resumes inside that item's dialog. If you close the create dialog without saving, the conversation stays an ordinary chat.

Once a saved check or template has at least one conversation, the panel header turns into a switcher listing your conversations about that item, with the one you are in highlighted. Each is labeled with the opening words of its first message and how long ago it was last active. Selecting another opens it, once the current reply has finished. To begin a fresh conversation instead, use New chat in the panel header, which appears as soon as the current conversation has messages and is unavailable until the current reply has finished. The conversation you leave stays in the switcher.

There is no switcher while you are creating something, however long the conversation gets, because there is no item yet to hold earlier conversations. In that case, and on a saved item you have never chatted about, the header simply reads Check Assistant or Template Assistant. New chat is still offered, so you can start over without leaving the dialog.

What the Assistant Can See

Each message you send carries a snapshot of the form as it currently stands, so the assistant can reason about what you have already filled in. The two dialogs send different snapshots, because a template holds fewer settings than a check.

In a quality check dialog, the snapshot covers the datastore and container, the rule type and its properties, the fields, the filter, the coverage, the description, the tags, the owner and the default anomaly assignee, the check's status, the field used for custom anomaly descriptions, any additional metadata, and whether a template is attached and locked. It also flags a check that is archived and a metric check that has already been asserted.

In a check template dialog, there is no datastore, container, fields, or ownership to send. The snapshot covers the rule type and its properties, the filter, the coverage, whether the template is locked, the description, the tags, and any additional metadata.

In both, if your last attempt to save failed, the error travels with it too, which is what lets the assistant help you work out why.

That snapshot is never shown in the conversation: your message bubble shows only the words you typed, both at the time and when you reopen the conversation later. Unlike the floating chat, this panel shows no context badge, because the form beside it is the context.

Long Conversations & Memory

AgentQ automatically manages conversation length to keep the context window efficient without losing important history.

How Compression Works

AgentQ keeps your conversation lean so the model stays fast and within budget:

1. Recent turns stay intact. The last 4 turns (user + assistant pairs) are always kept exactly as you wrote them.
2. Older tool activity gets dropped. In turns older than your last 4, tool calls and their results are replaced with a brief placeholder note, so a large output like a full container list isn't re-sent on every turn. What you wrote and what AgentQ answered stay in place.
3. At 10 messages, the conversation gets a summary. Once the session reaches 10 messages, AgentQ generates a structured summary of the conversation so far (around 500 words) and stores it with the session. The summary is included on every later turn and stays with the session even if you come back days later.

Information from early in a long conversation is not lost. It stays available to AgentQ as part of the summary throughout the session.

Background Streaming

If you navigate away from the AgentQ page while a response is being generated, the stream continues in the background. The full response is waiting for you when you return to that session.

For other interface tips like stopping a response or pasting large content, see Chat Interface Tips.

Session Persistence

Every conversation is saved. When you resume a session, AgentQ restores the full message history and the conversation summary, so it picks up exactly where you left off, even across days or sessions.

For step-by-step instructions on resuming a session, see Resume a Conversation.

Example Conversations

Investigating a Data Quality Alert

You: We got an alert about anomalies in the transactions table. What's going on?

AgentQ: I found 3 anomalies from the last scan. The most significant is a "Not Null" check failure on the merchant_id field. 247 records have null values where this field is expected to be populated. This started appearing after the batch that loaded at 2:00 AM. The affected records all have source_system = 'legacy_import'. Would you like me to show you the specific check that's failing or help investigate the source of these null values?

Setting Up Quality Monitoring for a New Dataset

You: We just connected a new PostgreSQL database called "ecommerce_prod". Can you help me understand what's in there and set up some basic quality checks?

AgentQ: I found 12 tables in the ecommerce_prod datastore. The main ones appear to be customers, orders, order_items, products, and inventory. Would you like me to describe the schema for any of these in detail?

You: Yes, tell me about the orders table and suggest some quality checks.

AgentQ: The orders table has 15 fields including order_id, customer_id, order_date, ship_date, status, and total_amount. Based on the schema, I'd recommend these quality checks:

• order_id should be unique
• customer_id should not be null
• total_amount should be positive
• ship_date should be after order_date when both are present
• status should be one of your valid status values

Want me to create these checks?

You: Yes, and also look at order_items. I think the same line shouldn't appear twice per order.

AgentQ: For order_items, the natural identifier is a pair like (order_id, line_item_id) rather than either column on its own. order_id repeats across line items in the same order, and line_item_id resets per order. I'll add a Unique check on both fields together so the combination is enforced as a composite key. Want me to apply it now?

Building Cross-System Analytics

You: I need to analyze customer lifetime value but our customer data is in Salesforce (synced to Snowflake) and our transaction data is in our PostgreSQL operational database. Can you help?

AgentQ: I can create a computed join that combines data from both sources. I'll join the customer table from your Snowflake datastore with the transactions table from PostgreSQL on customer_id. What fields do you need in the result? At minimum I'd suggest customer details, total transaction count, total spend, and first/last transaction dates.

You: That sounds right. Also filter out any test customers.

AgentQ: I've created a computed join called "customer_lifetime_value" that combines the data and excludes records where the customer email contains "test" or the customer_type is "internal". The join is now available as a container in Qualytics. Would you like me to set up quality checks on this new dataset or run a profile to understand the data distribution?