Three things appear on screen while you work: the query the agent ran, the commit you approved, and what the turn cost. Every one of them is real output from the product rather than a marketing rendering — so here they are, taken apart piece by piece.
Amber while the call is in flight, green when it returned. It is the same dot the product uses everywhere: amber is pending, green is a thing that happened.
Named from the catalog the agent chose from, so you can match what you're seeing against the complete list of fifteen. A card that says QUERY cannot have written anything.
How long your instance took and how many rows came back. Fourteen records means the answer above it was computed from fourteen records — not from a model's recollection of your data.
Not a paraphrase. The literal string sent to your instance, in the syntax your admins already write by hand. Copy it into a list view and you will get the same rows.
Cards appear inline in the conversation, in run order, before the answer that used them. You watch the agent work rather than reading a summary of the work afterwards.
Named exactly. A customer-visible comment and an internal work note are different fields and the line says which — the distinction people actually get wrong under pressure.
One record. Every action in the catalog touches exactly one, so there is no such thing here as a bulk update you have to reconstruct afterwards.
The moment the write landed, not the moment the draft was generated. Those are different times, and the gap between them is a person deciding.
A named human, and the same name your instance recorded in sys_updated_by, because the call ran on that person's own credentials. There is no service account to point at.
This line is Kaddiya's copy of the event. Your instance wrote its own, in its own audit tables, at the same instant — and that one is the record of truth. Ours is for finding things.
A cost figure whose model is a paragraph away is a figure nobody can check. The model that produced these tokens is on the same line as the tokens.
The actual counts your provider billed for this turn, reported back by the API, not an estimate from a word count.
Priced differently from fresh input, and usually most of the volume — which is why a turn that reads twelve thousand tokens of context still costs about a penny.
This figure comes from the same function the console runs, over these exact tokens, at your configured model's price. A test in the repository fails the build if the number on this page and the number that function returns ever disagree.
Billed to you by your provider at their published rates — we never hold your model key, so we could not meter you even if we wanted to. What connects today.
| Where it lives | How long | |
|---|---|---|
| Queries it ran | WhereIn the conversation, in Kaddiya. | How longAs long as you keep the conversation. Delete it and they go. |
| Writes you approved | WhereYour instance's own audit tables, plus an append-only log in Kaddiya. | How longYour instance's copy is yours and outlives us entirely. |
| Your OAuth token | WhereThe session, encrypted. | How longThe session. Sign out and it is gone — there is no durable token, because nothing runs when you're away. |
| Instance data it read | WhereThe conversation you were having, and nowhere else. | How longIt is never copied into a shared index, a training set, or another customer's context. |
| Notes about your instance | WhereKaddiya's notebook, never ServiceNow. | How longOnly if a human kept it. An unkept note is never used again. |