AI chat: ask your data

AI Chat is a data agent over your connected sources: ask a question in plain language and it answers with numbers, charts, and the SQL it actually ran.

Asking questions

Type anything from “Show top customers by revenue” to “Compare Q1 vs Q2 sales”. An empty chat suggests a few questions to start from, built from the page you are on and the measures in your data models: on a dashboard, Summarize this dashboard and questions about the measures its cards use (How has Margin changed by month?, Which Region has the highest Margin?); elsewhere, questions about your workspace’s measures. DataSquares writes them itself, naming only fields and measures you can ask about, and no AI runs until you pick one. You don’t pick a mode first: say what you want and the assistant reads the job from your words and the page you are on — a question gets an answer (as a chart or a table when you ask for one); “build a sales dashboard” proposes a new dashboard; “add a margin chart here” on a dashboard, or “rename Ops Weekly” from anywhere, proposes a change to that one. When it can’t tell — “add a revenue chart to the dashboard” with no dashboard open — it asks one short question with numbered choices, and you answer with the number or in words. The agent works in conversations — threads with history that persists across sessions; start a new chat per line of inquiry. Pick one from the conversation switcher at the top of the page; on a wide screen (1536 px and up) the history sits in a rail on the left instead, grouped Pinned, Today, Yesterday, Previous 7 days and Earlier, with New chat and search at its top (hide it with its button to get the room back). Reopening a thread restores it completely: the answers, the generated SQL, the charts, links to anything the agent created, and your own thumbs ratings — you pick up exactly where you left off.

Chat options, the button in the chat’s header, names how much work the AI puts into your next message: your company’s default effort until you choose one, then the one you chose. Open it for Quick, Balanced, Deep or Max, each named by the effort it gives, or press Ctrl+Shift+. (⇧⌘. on a Mac) while you type to move to the next one. Your choice is saved to your profile and stays on every device until you change it. A higher effort does more work and uses more AI credits; a conversation keeps its effort, and a higher one, or any move between Balanced, Deep and Max, applies from your next message (Effort in a conversation). Effort explains each choice, and what your company can set. When your company runs every conversation at one effort, Chat options has no Effort section. A message can be up to 10,000 characters long, in English or another language.

Four ways to ask

The chat panel — the AI button at the bottom right of the page opens the chat beside what you are looking at. The page rides along as the question’s context, shown as a chip on the message box (Dashboard · Sales pulse · 2 filters); remove it with its × to ask without it. The dashboard, report, story and presentation editors, and a dashboard in a window narrower than 1024 px, have no AI button: choose Search commands or ask AI in their top bar (or press Ctrl+K) and ask there.
The AI page — AI Chat in the menu opens the full workspace (below).
Ctrl+K (⌘K on a Mac) — type a question into the command palette and choose Ask AI: it is answered in the chat panel, about the page you are on (on the AI page, in the conversation open there). Ctrl+Enter (⌘↵) opens it on the AI page instead. With nothing typed, the palette suggests questions for the page, and Build a dashboard with AI… starts a new dashboard.
On a card — hover (or tab to) a chart or table card built on a data model and choose Analyze…: the Analyze panel, with an Ask about this card box at its foot that sends your question to the chat with the card and its filters as context.

The AI page: Split and Full

Split (the default on screens 1024 px and wider) — the conversation on the left, the result canvas on the right: each chart, table or figure appears there large, and a chip in the thread points to it (choose an earlier chip to bring that result back). One control shows the result as Chart, Table, SQL or Evidence; Save to dashboard sits beside it.
Full — one wide column with results inline under their answers; the Preview and Evidence panels open beside the thread.
Below 1024 px there is one column whatever you pick, with Preview and Evidence one tap away in the header.

What answers look like

Written answers with the supporting numbers, with the chart or table on the result canvas (Split) or inline under the answer (Full).
The generated SQL behind any query-backed answer is one click away — SQL on the result canvas, or a collapsible block under the answer. It is never shown until you ask — nothing is a black box.
Every chart says how much of the data it covers — “All 42 rows”, or why it is partial (the query stopped at its row limit and the source has more, or the chart shows a sample) — and View data opens the rows behind it as a table.
While it works, the agent lists its steps one below the other — each ticked when done, with what it touched and what came back (Querying the data · Orders · 4 rows). When the answer arrives it takes their place, and Show N steps brings them back. A question with several parts can get a plan you watch step by step, and you can ask for the answer before it is finished (While it works). It asks clarifying questions with clickable options when your question is ambiguous, but looks first: a question that doesn’t say what to measure is answered with the certified metric that fits (or, when none does, the one governed measure that fits), and the answer says which one it used. It asks which measure only when several fit equally well.
A status line under the working card’s title says what the AI is doing: for a question in English that names what it measures, within a moment of sending, what it read the question as (Looking at revenue for EMEA, last quarter); then, when there is one, a line on what it is doing between its steps: a short note on what it is working out, or one it writes before a step (Need the territory tables), which never opens the answer. It is not part of the answer, and it goes when the answer arrives. A longer note it wrote between its steps shows as it is written; once the answer arrives, the answer comes first and the note folds under it: Show working notes opens it, and Copy takes the answer alone.
Some questions are answered at once, without working them out: a question your admins verified, one number from a governed metric, the same answer again on fresh data, or one question back when yours could mean several things. See Questions answered at once.
An answer from your data ends with Ask next: up to four follow-up questions, built by DataSquares from the answer and the page with no AI, so showing them uses no AI credits (choosing one asks it, like any question). The ones marked with a flask are exploratory. An operator can turn them off. Answers also link to any dashboards or reports the agent created for you.
Under a finished answer: Copy; More detail, on the latest answer, which asks for the full breakdown, the method and the caveats (an AI request like any other); Add to story, which keeps the answer as an AI section in a story; and, where Presentations is available and the answer has a figure to show, Add to presentation.
The line beside DataSquares AI names the effort the answer ran at and how long it took (Deep effort · 4.2 s), and Response details under it list them. It never shows what the answer cost: AI credits are on the Usage page. An answer given at once (Questions answered at once) names no effort.
An answer that ended early says so, while it streams and when you open the conversation again: Response stopped when you stopped it, Response incomplete when an error cut it short, it reached the step limit or the length limit, a step took too long, or you asked for the answer now. What it had written so far is kept. The latest such answer offers Continue, which goes on from where it stopped: a new message that uses AI credits like any question, but reads the answer so far and what its steps found instead of starting over. Narrow it down puts your question back in the message box to make it smaller, and sends nothing. An answer whose steps ran but stopped before writing anything offers the same, never a Retry that would start the work over.
Nothing is written without your approval. When the agent would create or change something — a dashboard, report, card or filter, a metric alert, an email delivery schedule, a calculated field on a model, or a pipeline (creating one, adding a step, starting a run) — it first shows an approval card with exactly what will happen. Only that exact change runs, and only after you approve it; the card expires after ten minutes. Approving a change covers what the card shows, what applying it does, and what the agent adds to dashboards and reports in one approval.

While it works: plans, Stop and Answer now

On a server that turns plans on, a long answer works from a plan you can watch, and you can ask for the answer at any point. The working card under your question shows what is happening:

A plan for a question with several parts. A question with three or more parts (“why did margin fall in Q3, in which regions, and on which products?”), and at Deep and Max an analysis, starts with a short checklist of three to six steps. The working card shows it live: Step 3 of 6 beside the time, each step ticked when its work finishes, with what it found, and the steps it ran listed under the step that is running. DataSquares ticks the steps itself, as each one’s work finishes: the checklist is never the assistant’s own account of its progress. A lookup, a definition, one number or one chart gets no plan, and at Quick there is no checklist (a large build still starts from its build plan). If the assistant changes its plan, the new version says why. Once the answer lands, the plan folds into one line with the steps (Plan: 4 of 4 steps done), and Show opens the checklist.
Stop ends the answer where it is. What it had written is kept, labelled Response stopped.
Answer now appears once something has been found. The assistant stops between steps, stops the queries still running and answers from what it found, saying what it did not get to; the answer is labelled Response incomplete. A query it stopped shows as stopped in the steps, not as failed, and its plan step as not done. Something being saved, or a change being prepared for your approval, finishes first. During a build, what is ready is shown for approval, and you can ask it to continue with the rest. Like every request, it is charged for the AI work it did (AI credits).
Each question has a number of rounds of work it may use: up to 4 at Quick, 6 at Balanced, 8 at Deep and 10 at Max, and up to 12 in a conversation that builds dashboards or reports. They follow the effort you chose for that message: a lower effort chosen in a conversation sets them (and whether the question gets a plan) from your next message (Effort in a conversation). The assistant is told how many are left as it goes. When they are used up, the next round is its answer from what it found, with no more work, instead of a failure, and the answer is labelled Response incomplete.
When a question needs more work than usual, in AI chat on the web, the assistant pauses once its rounds of work are used up instead of answering at once. The working card says This needs more work than usual: continue, or show what we have. Continue gives it as many rounds again, at the same effort, or fewer when the question has too little time left for that many, so it still answers in time; it asks again if those run out too. Show what we have answers from what it found, labelled Response incomplete, as Answer now does. With no choice within five minutes, it shows what it has. The rounds it goes on for use AI credits like any other, so Continue goes on only while there are credits for them: once the credits have run out, or a monthly AI credit budget is used up, it shows what it has instead, and the working card says why. It does the same, and says so, when too little time is left for another round. A question with too little time left for another round and its answer doesn’t pause: it answers from what it found. The Android app doesn’t pause: it answers at the limit.
A query that keeps failing gets a second look. On a server that turns it on, when a query the assistant wrote still fails its own checks after two fixes in a row, such as a misspelled column or a join with no condition, it is reviewed once at the next effort up (from Deep, at Max’s), and the assistant goes on from the corrected query, or from what could not be fixed. The review is one of the question’s rounds of work and uses AI credits like any other step; it is skipped when the rounds left cannot cover it, and it happens at most once a question. A query refused because of who may read the data, a source that is not answering, or data that is not there is said as it is, never sent for review. One exception: a database that reports a table you may not read as a table that does not exist, as Oracle does, cannot be told from a misspelled name, so that query can get the review. Answer now or Stop pressed during the review ends it at once. At Max there is no effort above: the question stops there, and the assistant answers from what it found, saying what could not be done; the answer is labelled Response incomplete. On a server with the new tool set, the same goes for a query the assistant asks of your data model, such as one naming a field the model doesn’t have: the review answers with a query of the model again, never SQL. A field your admins hid or kept from the assistant, or one a sensitivity label keeps from you, is said as it is, never sent for review; a card’s own query is never reviewed.
A step that takes too long is stopped, not the whole answer. Each step has a time limit of its own. A query that runs too long is stopped and the assistant works around it; when the assistant itself takes too long once something was found, it answers from that, labelled Response incomplete. Writing its plan is not finding something: only results its queries and other work returned count. If that answer takes too long as well, what it had written of the answer stays and the reply says the answer was cut off before it was finished; when it had not begun one, the reply says that no answer was written. What was found stays in the steps. When nothing was found yet, the request ends with a note saying so (troubleshooting).
Resume. If the service restarts while a plan is running, the conversation shows where it stopped (Interrupted at step 4 of 7), and Resume picks it up at the first step not done. The steps already done keep what they found.

The plan is kept by DataSquares, not only in the conversation, so it holds however long the conversation grows. It names no AI model and no credit numbers.

Plans come from one of the AI tools, Writing the plan, which a workspace administrator can switch off (AI settings). With it off, no question gets a checklist, and a large build goes straight to its approval card, which still shows what will be created before anything is.

The DataSquares Android app does not show plans yet. A question asked on a phone still works from its plan, which you can see when you open the conversation on the web; while a build plan is waiting for you, the reply on the phone says to open the conversation on the web to choose Build this.

When something goes wrong, the answer goes on

An answer does not end because something went wrong on the way. It finishes, picks up again on its own, or ends with what it found, labelled:

The AI can’t be reached for a while. On a server that turns plans on, a question that can’t reach the AI waits for it instead of failing. The working card says The AI is busy right now; it will continue on its own., with how long it has waited so far. While it waits it tries again on its own: at once when the AI is back (The AI is answering again; continuing.), and every so often meanwhile (Trying the AI again.), so the answer usually goes on within a minute of the AI answering again. Any part of what was written before the AI stopped answering is written again, once. It waits up to ten minutes; after that — or sooner, when the AI keeps failing on the same step: three tries in all — the reply stops with what was found, labelled Response incomplete and ending (The AI could not be reached for a while, so this reply stops here with what was found so far. Ask again to continue.). Waiting uses no AI credits. While answers may be slower, the chat shows AI is catching up above the message box; it clears by itself.
Your connection drops. On a server that turns on picking answers up again, the answer keeps going while your connection is down: closing the tab, a laptop going to sleep or a network switching doesn’t stop it. When the connection is back, the chat reconnects by itself (Reconnecting…), shows what you missed and carries on, with nothing repeated; if you come back later, the answer is in the conversation. Stop still stops it.
The service restarts in the middle of an answer. On a server that turns on picking answers up again, an update or a crash doesn’t lose the answer: it picks up again on its own from its last finished step (Picking up where it left off.) — within seconds of an update, and about a minute and a half after a crash. What it had written after that step is written again, once. One that was waiting for you at its limit (continue, or show what we have) answers from what it found; rounds you had given it with Continue before the restart stay its own. A change it was in the middle of making is never made twice: if it can’t tell whether the change was made, it says so and asks you to check. An approved change that was being applied is closed, and its card says whether it was applied; ask for a fresh preview to try again. An answer interrupted again and again ends with what was found, labelled Response incomplete and ending (This reply was interrupted and could not be finished, so it stops here with what was found so far. Ask again to continue.).
The AI declines a request it should answer. An AI’s safety checks can misread an ordinary business question. When the AI declines one, another AI model takes the request over at once and answers it: you get one answer, as usual. Only when every one declines does the reply say I can’t help with that request. Ask me about your data, or to build or change a dashboard, report or Story.

An answer that waited, reconnected, picked up again or was taken over is still one answer and one charge, for the AI work it did, a declined attempt’s included (AI credits).

Build a dashboard

Ask for the dashboard in a sentence: “Build a sales dashboard with revenue by month, revenue by region and the top ten customers”. The assistant usually proposes a new dashboard first: Proposed dashboard lists the cards it would build, each with its chart type and what it is for, and the filters. Choose Build it, or say what to change; either one is another AI request. The assistant then shows an approval card with what it will create. Nothing is created until you approve it, and then the card links to the new dashboard.

On a server that turns plans on, how the build starts depends on its size:

Up to four cards on one page, an alert or a schedule: no separate plan. The assistant goes straight to the approval card, which shows what will be created: that card is the plan.
Five or more cards, several pages, or a report: a Build plan card first, at every effort level (unless an administrator has switched plans off), with the outline: each page and card, the question each card answers, and its chart type. It says that this is a large job, which uses more of your AI credits than a question. Nothing is built before you choose Build this, and DataSquares holds a large build back until you do:
- Edit lets you remove a card, move it up or down, rename it or change its chart type. Each edit applies at once, as a new version of the plan, with no AI request and no AI credits.
- Revise asks the assistant for a change in your own words, an AI request. The new version shows on the same card and says what changed and why.
- Build this approves exactly the version you see and starts the build. The plan card follows the build: it says it is building, then what the build left. Approving the plan writes nothing: the approval card still shows what will be created, and nothing is created until you approve it. If the assistant asks you something while it builds, your answer carries the build on: there is no second Build this. If the build cannot be made (a card needs a field the data does not have, say), nothing is created and the plan card says the build did not finish; ask again to try once more. If you choose Answer now before anything is ready, the card says that nothing was built.
- Cancel ends the plan, and nothing is built. A plan you cancel stays cancelled, even while a reply is still being written.

A long build keeps going. When a build’s steps fill most of what the AI can read at once, it sums up its earlier steps and goes on from that summary and its latest two steps. The summary keeps your request with every choice and correction you made, the names, filters and periods the build uses, each number it has shown you, and what is built and what is still to build. Nothing shows in the chat while it does this. Summing up is AI work, part of the answer’s one charge.

In the Ctrl+K palette, Build a dashboard with AI… opens the AI page with Build a dashboard about already in the message box, for you to finish. Nothing is sent until you send it. The separate dashboard generator page has gone: its old address opens the AI page the same way.

Approving a change

What the card shows

The approval card lists, in this order:

Destination — where the change lands; a link when the item already exists.
Kind of change — in plain words: New alert, Changed card, Removed card, New dashboard cards, New report blocks, New pipeline step, Pipeline run.
Affected — the items it touches.
Receipt expires — the time the card stops being valid, ten minutes after it was made.

Under them, What will change lists every change; for an existing item, each field’s value before and after. A removal adds a warning that the deletion is permanent. Long names wrap inside the card instead of running into the next fact. Approve and apply applies the change; Change lets you change it right there (Changing a proposal); Cancel just cancels it. Nothing is written unless you approve.

Changing a proposal

Change opens the parts of the proposed change on the card: a new dashboard’s name, each card and filter it would add, a new card’s title, or each field an update would change. Remove takes a part out (Keep puts it back) and a part with a title can be renamed where it is: its box starts from the whole title or value the change proposes, a description can run over several lines, and each takes as many characters as the item itself does (a name 255, a title 200, a filter’s label 60, a description 2,000). Check changes checks the edited proposal again, with the same checks the first preview had (your role, the fields it uses, the dashboard as it is now), and the card shows the result in place of the old one, saying Changed as you asked and checked again. No AI credits were used. Checking runs no AI. Approve and apply then applies the changed version. If the check refuses the edit (removing every part leaves nothing to apply, say), the card says why and keeps your edits to fix; the proposal stays as it was until a check passes. A proposal from a build plan can be changed this way while the plan is as it was; once the plan has changed or been cancelled, ask for a fresh preview instead. A proposal you have already approved, in another tab say, is no longer waiting: Change says so, and nothing is applied twice.

On the approval card of a big build, Change lists the cards the card shows (never one that was left out); the build is changed where it is kept and shown again, with no AI. A report’s commentary keeps quoting the cards it quoted when others are removed; removing a card it quotes is refused until you remove the commentary too, or keep the card. A commentary the card left out goes with a card it quotes when you remove that card.

A change that can’t be taken apart this way (an alert, a deletion, a schedule) offers Describe the change in the chat: it puts Change the proposal above: in the message box for you to finish, and sends nothing until you do — the assistant then prepares a new preview, which is AI work like any question. Close leaves the proposal as it was.

Applying it

Approve and apply applies exactly the change you reviewed, and DataSquares does it itself: it runs the approved call directly instead of asking the AI to repeat it, so it takes a moment, not another round of AI work. Before it writes:

the dashboard or report must not have changed since the preview;
for a build from a build plan, the plan must still be the version the preview was made under, and not cancelled. A preview made before the plan changed is not offered for approval at all;
your role must allow the change;
the AI tool behind it must be on for your workspace (admins switch AI tools on and off under Administration → AI: AI settings).

The card is where you read the result: the conversation gets no message of its own for it. While the change is being applied the card says so. After the write, DataSquares re-opens the item and the card shows Applied successfully with what it checked (the change landed, nothing else moved) — and, for a new dashboard or report, a link to what was built. If the change was refused, the card says Not applied and why (the dashboard changed since the preview, say); ask for a fresh preview to try again.

If the connection drops, or the tab sleeps, after the change is approved but before DataSquares has answered, the card says the change is Approved, not confirmed as applied yet, says what went wrong, and offers Try again. It sends the same approval again, and a change is applied only once: if the first press had already gone through, Try again shows the result (Applied successfully) instead of an error; if it was refused — the dashboard changed in the meantime, say — it says so, with the reason, and asks for a fresh preview; if it is still being applied, the card says that and you can ask again.

Applying a change you have already approved is not AI work, so it is never held back by your AI limits: a workspace that has used up its hourly or monthly AI budget, or its AI credits, can still apply — and Try again on — a change it has approved, and nothing is counted or charged for it. Asking the agent for the next change waits for the budget or the credits, as any question does.

Pressing the button adds no message from you to the conversation, and none of DataSquares’s own: the card says it all. The conversation keeps a record of what was applied for its history and the audit trail, and so the agent knows what was done when you ask the next question. Older conversations that stored the press as a message from you (“Apply the approved change exactly as reviewed.”) or the confirmation as a message of its own (“Applied. …”) no longer show them. Approving and then closing the tab still applies the change.

What the agent adds, and where

A finished dashboard. “Finish this dashboard: KPIs for revenue and orders, revenue against target by month for Europe, revenue by region” is one approval for the lot: KPI cards, trends — several values on one date axis, columns and lines for a value against its target — breakdowns, filters, and a filter on any one card. The cards already there move down, and none is deleted.
Tables, scatter plots, maps and text in the same approval. “Add the orders table, price against quantity, a map of revenue by country and a note on how to read it” goes in the same approval as the KPIs, trends and breakdowns, laid out after the breakdowns: scatter plots, then maps, two to a row, then tables and text the full width. A table can be a pivot table, and a scatter plot a bubble chart. Each table, scatter plot and map is checked against your model and tried on your data, as you, before the approval card appears, and the card shows its first rows and what they show. If one cannot be built (a sum of an identifier, a field your model does not have), nothing is created and the assistant fixes it first; one it cannot fix in two tries is left out, as in any build. Any other chart type (a donut, a funnel, a treemap, a waterfall, a radar, a heatmap, a sankey, a box plot, a bullet chart or a gauge) still comes as an approval each.
On the page you have open, or the one you name. In a dashboard with several pages, the cards and filters the agent adds go on the page you have open — in the editor or the viewer — and the approval card says which one. To put something on another page, say which: “add revenue by region to the Detail page” works for a single card, a filter, a chart of any type, or a finished dashboard, and the approval card names the page you asked for. The page is found by its name the way you say it (capitals and spacing do not matter). A name that matches no page of the dashboard, or two of them, adds nothing to a guess: the agent is given the page names to choose from. From anywhere else, or on a page you have not saved yet, they go on the first page.
Filters. Filter cards the agent adds are sized to their control: two rows for a dropdown or a date or number range, three for a list of values. A card the agent builds can carry its own filter, including a window that moves with the calendar: “the last 12 months” is still the last 12 months next quarter, and when one of the relative dates names the window you asked for, the agent uses it rather than two fixed dates. A slicer or a page filter only narrows a card’s own filter, never replaces it — see How filters combine.
A whole report. “Build a weekly KPI report: a summary, revenue by region as a chart, the top customers as a table” is one approval for the whole report — the text, chart and table blocks together, placed the way the report editor places blocks it adds at once: one under the next, a text block as tall as its text, a text block or a table the full width and a chart half of it. It works the same for a report that exists: several blocks go in below its last block — or, for a summary you ask for at the top, above the blocks already there, which move down — and nothing already there is deleted. Chart and table blocks can use your model’s SquareX measures and show their number format. One approval covers up to twelve blocks, and a single block can still be added, changed or deleted on its own — each its own approval.
Commentary from your data. A report’s summary or commentary can be written from numbers DataSquares computes rather than typed by the AI: a measure’s value, its change on the period before (or on the same period a year earlier), the members that drove that change, the leaders of a breakdown, values that stand out, or this period so far against a target (projected to the period’s end once a tenth of it has passed). A period counts as complete once it has ended both in UTC and in your workspace’s time zone. They are computed on your data, as you, before the approval card appears, and the AI writes only the words, in sections: the headline, the context, the drivers, then what to do about it. The approval card lists each number computed and anything flagged — a figure the AI typed that no computed number matches (a size typed with a sign, minus or plus, included: its direction belongs in words), or a word such as rose or up typed where the direction should follow the data — and a number that cannot be computed (no complete period yet, no data for the period just before, a result cut at its row limit) is said, never guessed. Every time the report is sent or exported, its commentary’s numbers are computed again, with the access the rest of the report is sent with; if one cannot be computed for that send, the commentary is left out with the reason instead of old numbers. Readers the commentary’s data is hidden from by row-level security see why instead of its numbers, in the report and when the assistant reads the report for them (reports). Once you edit the commentary’s words, they stay as you wrote them. A text block typed with numbers in it is shown on the approval card with those numbers marked as unchecked.

How the agent designs what it builds

Whatever the agent builds — a whole dashboard, a single card, a report’s chart or table — it follows the same design rules. They are part of DataSquares, not left to the AI, so they hold even when your request does not mention them.

Tried on your data before you approve

On your data, as you. Every chart, KPI, table and map the agent builds runs once on your data before the approval card appears, with your row-level security and masking applied. The approval card shows each card’s first rows and a one-line takeaway worked out from them, never invented.
Warnings, marked as warnings. The card marks what to check with a warning sign: No rows for these filters, more than half of a card’s values empty, 28 categories: showing the top 10 and Other, a pie drawn as bars because a part is below zero or you asked for every one of more than five parts.
Never kept broken. A card that cannot be built — a field the model does not have, a sum of an identifier, a query your database refuses — is not built, and the card says why (Not built: …); the rest is still built. The agent is given the exact reason and may repair a card twice; one that still fails is left out after two tries to repair it. When it was part of a whole dashboard or report the approval card says so; a single card or report block the agent could not build is reported in its reply.
What you approve is what you get. Approving applies the cards exactly as they were tried, without running them again.

The chart that fits

Lines for a trend over time, ranked bars to compare categories, a pie only for the parts of a whole — five slices at most — and a table when you ask for detail. When you did not name a chart type, the approval card names two or three other ways to show the chart (Other ways to show “Revenue by region”: column, table), so you can ask for one; a pie drawn as bars is offered as columns or a table, never as another pie.
A chart over a date is a trend, whatever its type: its periods are never cut into Other (with the new tool set, a ranking of periods you ask for, such as my best months, keeps its top 10 and Other), and its takeaway names only periods that are over. A pie, donut, treemap or sunburst over a date is drawn as columns in time order, and the approval card says why.
Top 10 and Other. A ranking of many categories shows the top 10 bars (a pie the top 4 slices) and Other, unless you ask for every one — then a pie of more than five parts is drawn as ranked bars of them all — and a bar chart grows taller for more bars, on a dashboard or in a report. A chart whose own settings already keep a top N keeps it. Other is the rest added up, so it appears only for values that add up — a sum or a count. An average, a minimum or a distinct count shows its top 10 with no Other, and a share of such values is drawn as ranked bars, never as a pie.

Numbers as your model formats them

Values carry the format your data model gives them: a SquareX measure’s own format, a field’s currency or percentage. A field with no format of its own is formatted by what it is — whole numbers for totals and counts, two decimals for averages — so a large total of such a field reads 2.3B, not 2345.7M. A SquareX measure with no format of its own is shown as the editor shows it. A currency is shown only when your model names it; it is never guessed from a symbol.
A count of an identifier is named after what it counts: Customers, not Distinct Customer ID.
When your request does not say how to add a field up, its default aggregation from the data model is used. A sum or an average of text, a date or an identifier — known by the model’s semantic type or by its name: an ID, a key, a code, a GUID, a SKU, or a number such as Order Number, Account No. or Invoice # — is never made, nor a sum or an average of a rate (a percentage) — not even when it is the field’s default in your model: an average of rates weighs a small order like a large one, so the agent uses a SquareX measure that computes the rate from its parts. A calculated field that adds itself up (a ratio of two sums) is taken as it is. This holds when the agent builds a card and when it changes one: an edit that would bring one in is refused with the reason before you are asked to approve it, while a card that already had one is not refused for an edit of something else.

KPIs that compare

A KPI the agent builds shows its latest whole period — this month so far is never set against a whole month — and its change against the period before, with a sparkline of whole periods. The line under its title names the period and what it is compared with (September 2026 · vs August 2026). With the new tool set, ask for a comparison with the same period last year, or with a target you give, and it compares with that instead.
It shows the same whole period on a dashboard, in a report, in a shared report or dashboard, and in exports: the PDF, PowerPoint and HTML exports print the period and its change under the value (September 2026 · +12.5% vs August 2026). The Android app shows such a KPI’s latest period, which may still be filling.
It runs on the date the trends built with it use, on a dashboard or in a report, or on the only date its data has. When the model has several dates and nothing says which, it stays one number, and the approval card says why — as does a KPI you limit to a window of its own on that date, which shows that whole window, never the latest period inside it: a single period (revenue this month), year to date, the last 30 days or 12 months, or two dates (revenue in Q1 2026). With the new tool set you can also ask for a KPI as one total.
For a cost — costs, refunds, returns, churn, delays, errors, ad or cloud spend — a rise is shown in red; a customer’s spend, profit and loss, or a portfolio’s returns are no cost. Where a governed metric of the KPI’s name says which way is better, it decides.
A KPI or a gauge on a dashboard or in a report with no rows for its filters says No data for these filters instead of 0, whoever built it.

A takeaway on every card

Charts the agent builds carry a one-line subtitle that says what the chart shows, by what, and how it is cut: Top 10 by Revenue, the rest added up as Other, Revenue by month and Region. It names no value and no category from your data, because everyone who opens the card sees it with their own row-level security and masking: the takeaway worked out from the rows (US leads with €60K, 60% of the total, a rate’s change in percentage points) is shown to you alone, on the approval card. A subtitle that would only repeat the title is left out. Edit or clear it as the card’s In-chart subtitle in the Format tab. KPIs, tables and scatter plots get none — a KPI states its own comparison, and a table is its rows.
A trend gets a dashed Average line — or, with the new tool set, a Target line when you give a target — and the value axis is titled with its unit (Revenue (EUR)).

Honest scales and colour

Bars start at zero. A second value axis is used only for values in different units, such as an amount and a percentage, or an amount and a count. When a rule undoes something a card asked for — a cut or log axis on bars, a second axis for values of one unit — the approval card says so.
Targets are drawn muted — a target line across a trend is dashed, as is a target that is the only line beside bars — last year in a lighter shade of this year’s colour, and Other in grey. Colours come from your dashboard’s theme, whose default palette is checked for colour-blind separation; the grey and the lighter shade keep at least 3:1 contrast against the card in every built-in theme whose own first colour does.

Where cards land

On the dashboard’s own grid, standard or condensed. A whole dashboard puts its filters first, then the KPI row, trends and breakdowns.
A single card goes where it was asked for when that spot is free. If another card is there, it goes to the next free row below, in the same columns, and the approval card says so. No card is placed on top of another.

After you approve

In the dashboard editor, the agent’s change is one step you can undo: Undo removes the cards it added and puts back the ones it moved, and your own earlier steps are kept.
The confirmation names any card the build left out, so you — and the agent, when you ask your next question — know what is still to do.

Building with the new tool set

On a server that turns the assistant’s new tool set on, building and changing work as above, with these differences. Approving still works the same way: nothing is written until you approve, and DataSquares applies exactly what the card showed.

One approval for a whole build

The layout on the card. Beside each card’s first rows and takeaway (see Tried on your data before you approve), the approval card shows how the cards are laid out, row by row. One approval covers the whole dashboard or report, up to 60 cards or blocks, as many as a build plan holds; a big build is built a few cards at a time and still comes as one approval card (Big builds, one approval).
Takeaways that compare like with like. A month (or week, or day) that may not be complete yet is never compared with a whole one: a chart of the last 12 months compares the last two months that are over, and says the current one may not be complete yet, with its value so far. A month dated after today, such as orders booked ahead, is named as in the future and never compared. A trend split by region compares the regions of one month with each other, never one region with another month. A histogram or a box plot is summed up by the spread of its values: how many, from the least to the most, and the median.
Any chart type you name. Beyond the chart that fits, any of the chart types you ask for by name where it fits what you want to see: a funnel, a treemap, a sunburst, a waterfall, a stacked area, a sparkline, a bubble chart, a heatmap, a sankey, a radar, a box plot, a bullet chart, a gauge for a KPI or a pivot table.
A new dashboard on a template. The assistant builds a new dashboard on the one of four templates that fits what you asked, and the approval card names it: Executive overview (the default: trends and breakdowns two to a row), Focus (one chart to a row, for a few charts read closely), Monitor grid (three to a row, for many measures side by side) or Briefing (the words, such as a takeaway paragraph, right under the KPIs). Every template puts the KPI row first, a filter bar at the top of each page and about eight KPIs, charts, maps and tables on a page: a bigger dashboard gets more pages, each named after what it starts with, unless you name the pages yourself, and the approval card says when a page you named holds more than fits one screen. Cards that answer the same business question sit together under a heading with that question (Where is revenue heading?).
Your workspace’s theme. A new dashboard uses your workspace’s dashboard theme, as any dashboard without one of its own does, and its headings take their colours from it. Ask for a theme by name (in Paper & Ink, or one of your workspace’s own) or for a compact layout and the dashboard is made with it; the approval card says Styled with your preferences: Paper & Ink, compact. A theme your workspace does not have is not guessed: the assistant says which there are. When your company locks its brand kit’s colours, a new dashboard or report is made in the brand kit’s look whatever theme you ask for, and the approval card says Made in your brand kit’s look: the company locks its colours. Under the font lock alone your theme is kept, set in the brand kit’s fonts, and the card says so (Brand kit).
Added where you say. Cards added to a dashboard that exists go at the bottom of the page, laid out filters first, then KPIs, trends, breakdowns, maps, tables and text, on the dashboard’s own grid, standard or condensed, so nothing already there moves; ask for at the top or under the revenue chart and the cards below move down together. Ask for beside the revenue chart and they go in the free columns next to it — or under it when there is no room, as the approval card says — or for wherever there is room and each fills the first gap it fits; either way nothing moves. Nothing lands on top of another card. They go on the page you have open or the one you name, and they land on the page the approval card names even if you open another page before you approve.
A takeaway paragraph. Ask for a summary of what the dashboard shows and the assistant adds a text card that says what each of its other cards shows and how it is cut, under the card’s title, after a line of its own if it writes one — in the words of the card’s own subtitle. It names none of your data: the card is read by everyone who opens the dashboard or report, a share, an embed or an export, each of whom may see other rows or see a value masked, so a leader or a total worked out from your rows would show them what they may not see. Nor does it quote a number: a commentary on the numbers is a text of its own, which a report can have (below). Each card’s takeaway from your data is on the approval card, which only you see. A summary of one business question takes only that question’s cards.
Pages. A new dashboard or report can have several pages in the same approval (an Overview page with the KPIs and a Detail page with the tables): each page is laid out from its top, and the approval card says which cards go on which page. To add to an existing dashboard or report, the assistant adds to one of its pages at a time, the one you name.
A report’s commentary from its own cards. A report’s text can quote the cards built with it — a KPI’s value, a trend’s change on the period before (split by a series, the members that drove it), a ranking’s or a share’s leaders — computed from each card’s own query, as you. It is written in sections: a headline, the context, the drivers, then What to do. The approval card names the block by what it will say and lists each number and anything flagged, and the numbers are computed again every time the report is sent, as above, with the report filters and parameters of the cards they quote. A text quotes at most 12 cards. A dashboard’s text is never computed again, so it quotes none; a text that types numbers itself is shown with them marked as unchecked.

Big builds, one approval

A build plan of many cards is built a few cards at a time, so no single step of the AI’s work has to hold the whole dashboard or report:

Each card checked as it is built. Every card is checked against your model and tried on your data, as you, as it is built and as the whole build will build it (a KPI on the date of the trend built with it, whichever step built that); nothing is created yet. A report’s commentary is checked against the cards it quotes, whichever step built them. A card a later step changes (a KPI whose trend is built after it) is tried again before the approval card shows it. The plan card shows how far the build has got (Build Sales overview · 6 of 14 cards ready).
One approval card for the whole build. When every card is ready, one approval card shows the whole build, up to 60 cards or blocks, as one approval holds, with the layout, each card’s first rows and takeaway, and what was left out; approving it creates exactly that, without trying the cards again. Its Change lists the cards it shows (Changing a proposal).
Two fixes at most. A card that cannot be built is tried again with a fix, as in any build; one that still cannot be built is left out after two tries to repair it, and the approval card says which and why. Each card of a step needs its own title (two the same would be one card), and a card given again later with the same title replaces it.
What you approve is what was shown. If the assistant adds to the build after the approval card is shown, that card no longer applies, and you get a fresh one. A build not shown within a day is dropped, and nothing of it was ever created.

Several changes, one approval

Ask for changes to a dashboard or report in one go (rename it, make the region chart a column chart and move it up): one approval card shows every field before and after, and only those fields change. Any card can be renamed or moved, headings, images and buttons included; turning a chart into a text card (or back) changes its content in the same approval. A chart you change is tried on your data first: the card shows how many rows it drew, its takeaway and its first rows, and a chart that does not run is not offered at all. Deleting a card or block is marked as permanent. If someone changed the dashboard since the assistant read it, nothing is applied: the assistant reads it again and prepares a fresh preview.

Alerts and email schedules in your time zone

Your time zone, never UTC by default. A schedule sends in your company’s time zone (Administration → General, Default Timezone), or in the one you name. If your company has never saved one, the assistant asks which time zone to use. The approval card shows when it will send (the next three sends, in that zone), the format and the recipients, and the schedule keeps the zone the card showed.
Up to 20 recipients. A schedule goes to you unless you name others, and the card flags any address outside the workspace. An alert notifies you in the app, or emails up to 20 members of the workspace.
“Me” is you. Email me and Ana sends a schedule or an alert to both of you: me is the email address on your profile. With none there, the assistant says so and asks you to add one or to name who should receive it.

SquareX measures

Describe the measure you need (net revenue without cancelled orders) and the assistant drafts it in SquareX, checks it and tries it on the data you can see (one value, or the top 10 by a field you name) before anything is saved. Saving puts it on the model, for every dashboard, report and metric that uses the model, through an approval card with the formula, its type and the test value; your role must allow creating models. A measure that does not check out, or a name the model already has, is never offered for approval. With the new tool set the assistant saves SquareX measures rather than calculated fields. Drafting needs Measure drafting to be on for your workspace (AI controls).

Not yet: Stories

Building into a Story, or changing one, is not available with the new tool set yet: the assistant says so, and you add to the Story in the Story editor.

Grounded in your governance

The agent doesn’t improvise definitions:

Governed metrics — ask “how is revenue pacing?” and it lists and evaluates your governed metrics (targets, certification and all) instead of hand-writing SQL for a KPI that already has a blessed definition. The number it gives is the one the metric’s cards show: its latest whole period, named (October 2026), with the change from the period before, whether it may still change, its target, and its pace over the period running now (for a metric that adds up). Ask for another period and it reads that one: the last complete week, month, quarter or year, one of them to date, one whole period such as 2026-Q3, or a range of days, in the workspace’s time zone, compared like for like with the period before or the same period last year, and narrowed by the metric’s own fields when you name part of its data. It gives all of a metric’s data only when you ask for an all-time total. It finds a metric by its name, its description or the glossary terms linked to it, certified and most-used first, and its trend leaves out the period in progress, and says so. A metric on a saved query answers too, with its trend, anomalies and forecast, read from its query as you; when row-level security applies to you on that query’s source, the assistant says it can’t read it for you. Reading metrics needs the Metrics view permission: for a role without it, the assistant reads no metric and names none, in an answer, a search or a quick answer, and answers from the data model’s own fields and measures. A metric built on a table or field outside the AI scope is not read for the AI.
Dashboard cards — Summarize this dashboard reads its cards’ rows as you: a card on a data model through the model, with your row-level security applied; a card backed by a saved query the way the dashboard runs it, refused when row-level security applies to you on its source. Your slicers on screen reach a saved query’s card when it has a column for them, and the answer says when one does not.
Business glossary — questions and field names are matched against your glossary, so “active customers” means what your organization defined it to mean.
Analysis tools — beyond queries, the agent can detect anomalies, surface key influencers behind a change, forecast a trend (the same statistics behind card insights), and even create a metric alert for you when you ask to be told next time; like any new alert on a metric, it compares the metric’s latest whole period.

On a server with the new tool set

From the API revision of 7 November 2026, these are the assistant’s only tools: a conversation started on the older ones moves to them with its next message.

Answers from your data model first. The assistant asks your data model for the measures, dimensions and period a question needs: the model’s relationships make the joins, and when two paths could join the same tables it says so instead of picking one. SQL it writes itself is a fallback for what the model cannot ask, and the answer says it came from SQL on the source. A filter keeps rows before anything is added up: revenue of the orders over 100 adds up those orders. When row-level security applies to you, it answers from the model, filtered to your rows, where it used to stop.
It checks before it answers. When a filter value matches nothing it says so and looks up how your data spells it (NY or New York); when a period has no data it says where your data’s dates run; every complete breakdown of sums and counts is checked against its total, and when it does not add up it says so; and when a data-quality check on the data is failing, or a synced source is late, the answer says that too.
It says when an answer is cut. An answer stops at 1,000 rows, or at the number you ask for (the top 10 products). When your data has more, the assistant says the answer is the first rows, never all of them, and gives no total of those rows. A card read with its own row limit is said to be the card’s top rows. Compared with another period, such an answer is compared for its own rows: the top 10 products this month against last month sets last month’s figures for those 10 products beside them.
Comparisons follow the calendar. Compared with the period before, whole calendar months, named or given as their dates, are set beside as many whole months just before them (September beside August, the third quarter beside the second, February to April beside November to January, a fiscal year beside the one before); year to date and the last 12 months beside the same span a year earlier; and a rolling window, such as the last 7 or 30 days, or other dates, such as 1 to 10 March, beside the same number of days just before. Compared with last year, whole months are compared whole, so a February in a leap year keeps its 29th. Why a number moved (below) compares periods the same way.
Large models. Where the server turns on the schema finder, it works with the new tools too: at the efforts it runs at, on a model larger than the answer’s effort reads whole, the finder hands the assistant the part of the model your question needs, and the assistant can ask it again when something is missing, as often as the effort allows. The finder works on the model the assistant chose: when your workspace has several and the question names none, the assistant picks one from your models, or asks you which.
Questions with options. When your request could mean different things, it asks up to three short questions, each with a few options and the one it recommends; pick one, or answer in your own words.
Verified answers your admins added are found by their words and run on fresh data, marked Verified answer.
It reads what you can open: dashboards, reports and Stories, one card or one report block, with the first rows of each card as you would see them, under the slicers you have set; a slicer on a field your admins keep from the assistant is not applied, and it says so. A Story is listed under the title you would see, and its sections your data access does not reach are left out.
Charts are chosen by rules: lines for time, ranked bars for categories, a pie only for five parts or fewer, and the rest of a top list as Other only when its values add up. An answer cut at its limit is never drawn as shares of a whole or with Other: the assistant reads every row first, or charts the rows it has as a ranking. A chart you ask for is drawn with the answer, in the same step, from the rows the answer read; when it cannot be drawn, the answer still comes, with the reason.
A share is of the whole. A pie, or bars of 100%, shows every part, each with all its rows added up, and only values that add up, such as revenue or a count of orders; split by a second field, such as status, each part is one bar of 100%. A top list without Other, or an average, a minimum, a maximum or a change from another period, is drawn as a ranking, with no share of a total.

Admins see the new tools under AI tools while the server has them on; switching off every tool a new one takes over switches it off too (AI tools).

On a server that turns the new tool set on, these analyses run on your governed data, as you, with your row-level security and masking applied, and DataSquares computes the numbers the assistant puts into words:

Why a number moved. A governed metric, a model’s measure or a field, in one period against the period before (whole months against as many whole months before them, so September is compared with all of August; year to date and the last 12 months against the same span a year earlier; a rolling window, such as the last 30 days, or any other span against the same number of days just before it: the way answers compare periods), the same dates a year earlier (whole months whole, a leap year’s 29 February included), another period or the metric’s target. A target is set for one period of the metric’s grain, so it is compared with one whole day, week, month, quarter or year. For up to five dimensions it gives each member’s part of the change, as a share of the change when the number adds up over the members; given the volume the number is a total or an average of (orders, units), it splits the change into volume, mix and rate, which add up exactly to the change. When one member carries the whole number (a dimension your filter pins to one value, say), that can’t show whether a metric or a measure adds up, so no share or split is given and the answer says why; a field summed, counted or averaged is split as what it is. It can also rank the dimensions whose members explain most of a numeric field’s spread. A period that hasn’t ended yet is flagged, since part of it is still to come.
Trends, anomalies and forecasts on a governed series by day, week, month, quarter or year. Periods with no data are named, and a series longer than one query returns is refused rather than read from its first part. A period that hasn’t ended yet is left out of the trend, the anomalies and the forecast and named, so a month only partly in never reads as a drop; so is a period only partly inside the dates read (a week that began before them), and the last twelve months start on the first day of the week, month or quarter they begin in.
A look at a table’s columns before you model it or build a pipeline: counts, empty values, distinct values, the most frequent values first and ranges, or sample rows. Columns under a sensitivity label you may not read in clear are hidden, and it isn’t available to people a row-level-security policy applies to, since it reads the table without the model’s row filters.
How far to trust the data: for a table, a data model, a field or a result, its freshness, the daily row-count check, the data quality checks on it with their last run and failing rows, open incidents, and whether its model is certified. A data model’s tables come a page at a time, the ones needing attention first, with a summary of all of them. It needs permission to view data quality, and isn’t shown to people a row-level-security policy applies to.

Pipelines from chat

When your workspace has Pipelines, the agent can work with them too — under the same role rules as the Pipelines page (viewers can ask about pipelines; editors can build them):

Ask about them — “which pipelines failed last night?”, “why did Orders nightly fail?” — it reads the run and each step’s outcome.
Build one — “load the orders table from Shop DB into a dataset and a copy in our warehouse, only paid orders, every night at 2, and run it now”. It looks up your connections and their tables, checks the steps with the same validation the editor runs (every source and destination must be one of yours), and shows ONE approval card: every step, each destination, the schedule in plain words with its next run, and whether it starts now. Loading into one of your own database tables in replace mode empties that table on every run — the card marks that as destructive.
Change or run one — add a step (for example a filter between the extract and the load) or start a run. Each is its own approval card; if the pipeline is edited in the page after the card was made, the approved change is refused rather than applied to a different version.
Preview a transform — the SQL a step compiles to and sample rows from the last successful run (named, never passed off as live data).
Why did it fail? What does it cost? — it explains a failed run from its diagnosis and can propose the fix, and it estimates a pipeline’s execution time with concrete ways to make it cheaper or faster (Cost & performance).

If Pipelines isn’t on your plan, or your administrator has turned it off, the agent says so plainly.

On a server that turns the new tool set on, the same rules hold, and:

A draft and a dry run before anything is saved. The agent checks the pipeline with the editor’s validation and shows the SQL each transform step compiles to. A dry run adds how many rows each step read and wrote in the pipeline’s last successful run, each transform’s rows from that run’s data with empty values and repeated rows counted, and the cost estimate. Those rows are shown only when everything they come from is data you may read: tables inside the AI scope, on a connection where no row-level security policy applies to you, with no column under a sensitivity label hidden from you (and, for a viewer, tables a data model is built on). They’re also shown only when that run’s data comes from the steps the transform reads now: not when the pipeline has changed since that run began, or when the change being drafted alters a step the transform reads from. Otherwise the transform’s SQL is shown without rows, with the reason. A dry run runs nothing: a sample run of a draft isn’t available yet, and the answer says so.
Changes step by step, in one approval. Add, replace or remove steps, make a step read from another, rename the pipeline, or set or remove its schedule. The steps you don’t mention stay exactly as they are, including ones only the editor can set up, such as a file or API extract. A step it replaces keeps what only the editor sets on it: its schema drift policy, its parallel reads, its retries and run condition, and its file, Google Sheets and API deliveries (change those in the editor). The card names, on a line of its own, anything a change drops, such as a dataset it no longer loads or a cursor that read only new rows. Removing a step, or dropping a load’s destination or a strict drift check, is marked destructive on the card, and if the pipeline is edited in the page after the card was made, the change is refused rather than applied to a different version. A change too large for one approval card (a very long SQL step, say) is refused before any card, with how to save it in parts, or you can build it in the editor.
The run card shows what a run uses: the month’s Pipelines execution hours (used, included and left), the time it is expected to take from its own history, and its steps. When the month’s hours are used up and runs are refused, it says so before showing a card.
Schedules as they stand. A pipeline’s schedule names its next run only while it is on. One switched off says so, and one DataSquares paused after its runs kept being refused for the same reason says why and what to fix, so the assistant never promises a run that won’t happen.
Your connections: it lists them, searches their tables (tables outside the AI scope aren’t listed), and tests one, saying why it can’t connect in plain words (the sign-in, the network, the database name, the secure connection) without repeating the server’s own error text.

From answer to dashboard

Save to dashboard is on every answer with a chart, a table or a figure, in the chat panel and on the AI page. You choose the dashboard, or start a new one if you may create dashboards; saving runs no AI and uses no AI credits. A query-backed result becomes a live card — backed by a saved query, re-runs on refresh, and participates in the dashboard’s filters.

A chart-only result saves as a static snapshot: the chart as the AI drew it from your data. Because it shows its author’s rows, it is hidden from anyone a row-level security policy in the workspace applies to, and on shares and embeds that apply row filters; public and password links still show it. In its place they see “This card is a snapshot of its author’s data, so it is hidden for you. Ask the author to make it a live card.” To show everyone their own rows, rebuild the card on a data model, a metric or a saved query. An editor the chart is hidden from can still rename or restyle the card without removing it for others. Live cards are unaffected.

Practical notes

Rate the answers. A thumbs-up on an answer that used your data becomes an example the AI follows for your own later questions (the approach, not the values). A thumbs-down asks what was wrong (Wrong number, Wrong filters or period, Wrong data, Incomplete, Not what I asked, Too long or Something else) with room for a note of up to 1,000 characters, and a correction you type is kept as a note for your later chats: see what DataSquares keeps. You see and edit those notes under Settings → Memory, a correction reaches other people only once it is reviewed, and Incognito keeps a new chat out of memory.
If a request fails, Retry request sends it again and Edit request puts it back in the message box to change; a request to build something can also be sent as Answer without changing anything.
Report this answer, under an answer, reports one that is offensive, harmful or wrong: choose a reason, add a note if you like, and send it. The report keeps the answer as you saw it; DataSquares reviews it on the hosted service, the people who run a self-hosted server on theirs.
Errors say what’s actually wrong: if AI hasn’t been configured on the server you’re told exactly that (ask your admin), and limits — used-up AI credits, or a limit on the workspace’s AI use — are called out distinctly rather than surfacing as a generic failure. When the AI can’t answer covers each one.
The chat shows no AI credit numbers, to anyone: how many credits are left, and what each person and workspace used, are on the Usage page (AI credits).
Response details, under an answer, shows how long it took. Admins set how carefully the assistant works, how long its answers may be and any limit on the workspace’s AI use in workspace settings.
Evidence (on the result canvas in Split, or its panel in Full) shows what an answer rests on: the data sources and metrics by name, the filter values and time range, whether the data was read live or came from the query cache, how much of it a chart covers, anything the answer assumed (for example, no time range), and any warnings. Exporting a conversation includes the same evidence, so an answer can be reproduced.
If the connection drops just as an answer finishes, the chat restores the finished answer from the server instead of leaving it cut off. On a server that turns on picking answers up again, it reconnects to an answer still being written and carries on (When something goes wrong).

Accessibility and phones

One status line tells a screen reader how a question is going: the working card says each step while the AI works, and when the answer is ready the chat says so once (Answer ready., The assistant asked a question., or Approval needed: … Nothing changes until you approve it.). An answer cut short says Answer stopped early. Continue goes on from what it found., or Answer stopped. … when you stopped it. The answer’s text is not read out word by word as it arrives; an error says so itself.
Focus stays in the message box after an answer, so you can ask the next question. When an answer ends on an approval card, focus moves to the card, unless you had moved focus out of the chat.
Outside the chat each AI tool says in a status line of its own that it is working and when its result is ready, and moves focus to the result: Analyze and Explain this change on a card, a metric’s Explain, a shared view’s Ask AI (focus goes to the reply), and Draft with AI in the measure editor (focus goes to the draft). Change on an approval card says in the same way which part you removed or kept, and when it is checking your changes.
On a phone every place you type a request to the AI uses 16 px text, so the page does not zoom in when you tap it: the message box, the home page’s question box, Ask about this card, the command palette, Write with AI and Start from a goal in Stories, Draft with AI in the measure and theme editors, a pipeline step’s Describe it, and a shared view’s Ask AI. Send and Stop, the suggestions, an answer’s own buttons and choices, and the approval card’s buttons are at least 44 px tall there.

On mobile

The Android app has AI Chat, opened from Home, from a search (“Ask AI: …”) or from Ask about this on a Needs attention card: the same governed agent, streaming answers with live tool progress, links that open the dashboards it creates for you, and conversation history you can resume or delete. It appears only when your server has AI configured and your role may use it.

The app does not reconnect to an answer yet: leaving the app or losing the connection stops the answer, as before, and what it had written is kept. While the AI can’t be reached the answer waits and goes on, but the app shows neither the waiting lines nor the AI taking back the start of a step it runs again: that start may show twice until you reopen the conversation, which shows the answer as it was saved, written once.

If an answer is offensive, harmful or wrong, tap Report beside its thumbs, choose a reason, add a note if you like, and Send report. The report keeps the answer as you saw it, and the confirmation says who reviews it: DataSquares on the hosted service, or the people who run a self-hosted server.

AI in DataSquares — every place the AI appears, effort and AI credits.
What the AI can and cannot do — the limits worth knowing before you rely on an answer.
How the AI uses your data — what it is sent, what DataSquares keeps.
Memory — what the AI remembers, incognito chats, the AI brief and design preferences.
Saved queries — where query-backed cards live.